def butter_filter(x, y, cutoffs, Btype = 'low', ax = 0, bl = 3, GP = 1, GS = 30, padtype=None, padlen = None): """ low, high or band pass butterworth filter: cutoffs is the low and high frq edges of pass band. """ x = x - x[0] if x.ndim == 1: dt = np.diff(x).mean() df = 1./(x[-1]-x[0]) else: dt = np.diff(x, axis=0).mean() df = (1./(x[-1]-x[0]))[0] nyq = 0.5 * (1. / dt) bl = int(bl) if Btype == 'band': order, wc = buttord(cutoffs/nyq, [cutoffs[0]-bl*df, cutoffs[1]+bl*df]/nyq, gpass = GP, gstop = GS) elif Btype == 'low': order, wc = buttord(cutoffs/nyq, (cutoffs+bl*df)/nyq, gpass = GP, gstop = GS) elif Btype == 'high': order, wc = buttord(cutoffs/nyq, (cutoffs-bl*df)/nyq, gpass = GP, gstop = GS) else: raise ValueError, "Btype is low, high or band only." b, a = butter(order, wc, btype = Btype) yn = filtfilt(b, a, y, axis = ax, padtype = padtype, padlen = padlen) return yn
def prepare_audio_filters(): tf_rangel = 100000 tf_rangeh = 170000 # audio filters tf = SysParams['audio_lfreq'] N, Wn = sps.buttord([(tf - tf_rangel) / (freq_hz / 2.0), (tf + tf_rangel) / (freq_hz / 2.0)], [(tf - tf_rangeh) / (freq_hz / 2.0), (tf + tf_rangeh) / (freq_hz / 2.0)], 5, 15) Faudl = filtfft(sps.butter(N, Wn, btype='bandpass')) tf = SysParams['audio_rfreq'] N, Wn = sps.buttord([(tf - tf_rangel) / (freq_hz / 2.0), (tf + tf_rangel) / (freq_hz / 2.0)], [(tf - tf_rangeh) / (freq_hz / 2.0), (tf + tf_rangeh) / (freq_hz / 2.0)], 5, 15) Faudr = filtfft(sps.butter(N, Wn, btype='bandpass')) N, Wn = sps.buttord(0.016 / (afreq / 2.0), 0.024 / (afreq / 2.0), 5, 15) FiltAPost = filtfft(sps.butter(N, Wn)) N, Wn = sps.buttord(3.1 / (freq / 2.0), 3.5 / (freq / 2.0), 1, 20) SysParams['fft_audiorf_lpf'] = Faudrf = filtfft( sps.butter(N, Wn, btype='lowpass')) SysParams['fft_audiolpf'] = FiltAPost #* FiltAPost * FiltAPost SysParams['fft_audio_left'] = Faudrf * Faudl * fft_hilbert SysParams['fft_audio_right'] = Faudrf * Faudr * fft_hilbert
def butter_bandpass(lowcut, highcut, samplingrate, order=4): nyq = 0.5 * samplingrate low = lowcut / nyq high = highcut / nyq print high, low if high >=1. and low == 0.: b = np.array([1.]) a = np.array([1.]) elif high < 0.95 and low > 0. : wp = [1.05*low,high-0.05] ws = [0.95*low,high+0.05] print wp,ws order,wn = buttord(wp,ws,0., 30.) b, a = butter(order, wn, btype='band') elif high>= 0.95: print 'highpass',low,1.2*low,0.8*low order,wn = buttord( 15*low,0.05*low,gpass=0.0, gstop=10.0) print order,wn b, a = butter(order, wn, btype='high') elif low <= 0.05: print 'lowpass',high order,wn = buttord( high-0.05,high+0.05,gpass=0.0, gstop=10.0) b, a = butter(order, wn, btype='low') return b, a
def butter_bandpass(lowcut, highcut, samplingrate, order=4): nyq = 0.5 * samplingrate low = lowcut / nyq high = highcut / nyq if high >= 1. and low == 0.: b = np.array([1.]) a = np.array([1.]) elif high < 0.95 and low > 0.: wp = [1.05 * low, high - 0.05] ws = [0.95 * low, high + 0.05] order, wn = signal.buttord(wp, ws, 3., 40.) b, a = signal.butter(order, wn, btype='band') elif high >= 0.95: print 'highpass', low, 1.2 * low, 0.8 * low order, wn = signal.buttord(15 * low, 0.05 * low, gpass=0.0, gstop=10.0) print order, wn b, a = signal.butter(order, wn, btype='high') elif low <= 0.05: print 'lowpass', high order, wn = signal.buttord(high - 0.05, high + 0.05, gpass=0.0, gstop=10.0) b, a = signal.butter(order, wn, btype='low') return b, a
def prepare_audio_filters(): tf_rangel = 100000 tf_rangeh = 170000 # audio filters tf = SysParams["audio_lfreq"] N, Wn = sps.buttord( [(tf - tf_rangel) / (freq_hz / 2.0), (tf + tf_rangel) / (freq_hz / 2.0)], [(tf - tf_rangeh) / (freq_hz / 2.0), (tf + tf_rangeh) / (freq_hz / 2.0)], 5, 15, ) Faudl = filtfft(sps.butter(N, Wn, btype="bandpass")) tf = SysParams["audio_rfreq"] N, Wn = sps.buttord( [(tf - tf_rangel) / (freq_hz / 2.0), (tf + tf_rangel) / (freq_hz / 2.0)], [(tf - tf_rangeh) / (freq_hz / 2.0), (tf + tf_rangeh) / (freq_hz / 2.0)], 5, 15, ) Faudr = filtfft(sps.butter(N, Wn, btype="bandpass")) N, Wn = sps.buttord(0.016 / (afreq / 2.0), 0.024 / (afreq / 2.0), 5, 15) FiltAPost = filtfft(sps.butter(N, Wn)) N, Wn = sps.buttord(3.1 / (freq / 2.0), 3.5 / (freq / 2.0), 1, 20) SysParams["fft_audiorf_lpf"] = Faudrf = filtfft(sps.butter(N, Wn, btype="lowpass")) SysParams["fft_audiolpf"] = FiltAPost # * FiltAPost * FiltAPost SysParams["fft_audio_left"] = Faudrf * Faudl * fft_hilbert SysParams["fft_audio_right"] = Faudrf * Faudr * fft_hilbert
def prepare_audio_filters(): forder = 256 forderd = 0 tf_rangel = 100000 tf_rangeh = 170000 # audio filters tf = SP["audio_lfreq"] N, Wn = sps.buttord( [(tf - tf_rangel) / (freq_hz / 2.0), (tf + tf_rangel) / (freq_hz / 2.0)], [(tf - tf_rangeh) / (freq_hz / 2.0), (tf + tf_rangeh) / (freq_hz / 2.0)], 1, 15, ) Baudl, Aaudl = sps.butter(N, Wn, btype="bandpass") tf = SP["audio_rfreq"] N, Wn = sps.buttord( [(tf - tf_rangel) / (freq_hz / 2.0), (tf + tf_rangel) / (freq_hz / 2.0)], [(tf - tf_rangeh) / (freq_hz / 2.0), (tf + tf_rangeh) / (freq_hz / 2.0)], 1, 15, ) N, Wn = sps.buttord( [(tf - tf_rangel) / (freq_hz / 2.0), (tf + tf_rangel) / (freq_hz / 2.0)], [(tf - tf_rangeh) / (freq_hz / 2.0), (tf + tf_rangeh) / (freq_hz / 2.0)], 5, 15, ) Baudr, Aaudr = sps.butter(N, Wn, btype="bandpass") N, Wn = sps.buttord(0.016 / (afreq / 2.0), 0.024 / (afreq / 2.0), 2, 15) audiolp_filter_b, audiolp_filter_a = sps.butter(N, Wn) # USE FIR audiolp_filter_b = sps.firwin(257, 0.020 / (afreq / 2.0)) audiolp_filter_a = [1.0] N, Wn = sps.buttord(3.1 / (freq / 2.0), 3.5 / (freq / 2.0), 1, 20) audiorf_filter_b, audiorf_filter_a = sps.butter(N, Wn, btype="lowpass") [Baudrf_FDLS, Aaudrf_FDLS] = fdls.FDLS_fromfilt(audiorf_filter_b, audiorf_filter_a, forder, forderd, 0) SP["fft_audiorf_lpf"] = Faudrf = np.fft.fft(Baudrf_FDLS, blocklen) [Baudiolp_FDLS, Aaudiolp_FDLS] = fdls.FDLS_fromfilt(audiolp_filter_b, audiolp_filter_a, forder, forderd, 0) FiltAPost = np.fft.fft(Baudiolp_FDLS, blocklen) SP["fft_audiolpf"] = FiltAPost * FiltAPost # * FiltAPost [Baudl_FDLS, Aaudl_FDLS] = fdls.FDLS_fromfilt(Baudl, Aaudl, forder, forderd, 0) [Baudr_FDLS, Aaudr_FDLS] = fdls.FDLS_fromfilt(Baudr, Aaudr, forder, forderd, 0) Faudl = np.fft.fft(Baudl_FDLS, blocklen) Faudr = np.fft.fft(Baudr_FDLS, blocklen) SP["fft_audio_left"] = Faudrf * Faudl * fft_hilbert SP["fft_audio_right"] = Faudrf * Faudr * fft_hilbert
def __parameters_custom_order(self): order = self.custom_order if self.approx_type == 'butterworth': N, self.wn = signal.buttord(self.wp, self.ws, self.template.att_p, self.template.att_s, analog=True) N_norm, self.wn_N = signal.buttord(self.template.omega_pN, self.template.omega_sN, self.template.att_p, self.template.att_s, analog=True) elif self.approx_type == 'bessel': pass elif self.approx_type == 'cheby_1': N, self.wn = signal.cheb1ord(self.wp, self.ws, self.template.att_p, self.template.att_s, analog=True) N_norm, self.wn_N = signal.cheb2ord(self.template.omega_pN, self.template.omega_sN, self.template.att_p, self.template.att_s, analog=True) elif self.approx_type == 'cheby_2': N, self.wn = signal.cheb2ord(self.wp, self.ws, self.template.att_p, self.template.att_s, analog=True) N_norm, self.wn_N = signal.cheb2ord(self.template.omega_pN, self.template.omega_sN, self.template.att_p, self.template.att_s, analog=True) elif self.approx_type == 'legendre': pass elif self.approx_type == 'gauss': pass elif self.approx_type == 'cauer': N, self.wn = signal.ellipord(self.wp, self.ws, self.template.att_p, self.template.att_s, analog=True) N_norm, self.wn_N = signal.ellipord(self.template.omega_pN, self.template.omega_sN, self.template.att_p, self.template.att_s, analog=True) return order
def ButterworthBandpass(self,data,sampleRate,low=0,high=None,minFreq=0,maxFreq=None,order=10,band=50): """ Basic IIR bandpass filter. Identifies order of filter, max 10. """ if data is None: data = self.data if sampleRate is None: sampleRate = self.sampleRate if high is None: high = sampleRate/2 if maxFreq is None: maxFreq = sampleRate/2 low = max(low,0,minFreq) high = min(high,maxFreq,sampleRate/2) if low == minFreq and high == maxFreq: print("No filter needed!") return data nyquist = sampleRate/2 if low == minFreq: # Low pass cut1 = high/nyquist cut2 = (high+band)/nyquist # calculate the best order order,wN = signal.buttord(cut1, cut2, 3, band) if order>10: order=10 b, a = signal.butter(order,wN,btype='lowpass') elif high == maxFreq: # High pass cut1 = low/nyquist cut2 = (low-band)/nyquist # calculate the best order order,wN = signal.buttord(cut1, cut2, 3, band) if order>10: order=10 b, a = signal.butter(order,wN, btype='highpass') else: # Band pass lowPass = low/nyquist highPass = high/nyquist lowStop = (low-band)/nyquist highStop = (high+band)/nyquist # calculate the best order order,wN = signal.buttord([lowPass, highPass], [lowStop, highStop], 3, band) if order>10: order=10 b, a = signal.butter(order,wN, btype='bandpass') #b, a = signal.butter(order,[lowPass, highPass], btype='bandpass') return signal.filtfilt(b, a, data)
def _build_lpfilter(self, fs): """ builds low-pass filter with a cutoff frequency of 3/7th the resample frequency. The filter should be down 40 dB at 1.5 times the cutoff frequency (6/7th) the resample frequency. Parameters ---------- fs : the base sampling rate Returns ------- b, a : array_like Numerator (b) and denominator (a) polynomials of the IIR filter. """ nyq = fs / 2. # nyquist frequency cutoff = (3. / 7.) * self.resample_fs # cutoff freq defined by Boer wp = cutoff * nyq # pass edge freq (pi radians / sample) ws = wp * 2. # pass edge freq (pi radians / sample) gpass = 1.5 # The maximum loss in the passband (dB) gstop = 40 # The minimum attenuation in the stopband (dB) n, wn = buttord(wp, ws, gpass, gstop) #print('n =',n,'wn =',wn) b, a = butter(n, wn, analog=True) return b, a
def bpf(x, pass_freq=[3., 35.], cut_freq=[0.5, 40.], sample_rate=100): wp = list(np.array(pass_freq)/(sample_rate/2)) ws = list(np.array(cut_freq)/(sample_rate/2)) N, Wn = signal.buttord(wp, ws, 3, 40, False) b, a = signal.butter(N, Wn, btype='bandpass', analog=False, output='ba') y = signal.lfilter(b, a, x) return y
def lpf(x, pass_freq=35., cut_freq=40., sample_rate=100): wp = pass_freq/(sample_rate/2) ws = cut_freq/(sample_rate/2) N, Wn = signal.buttord(wp, ws, 3, 40, False) b, a = signal.butter(N, Wn, btype='low', analog=False, output='ba') y = signal.lfilter(b, a, x) return y
def __init2(self, _wp, ws, filter, *args): if ws is not None: order, _wp = buttord(_wp, ws, args[0], args[1]) if (len(np.atleast_1d(_wp)) == 1) and (filter[0].lower() == 'b'): if filter == 'bandpass': filter = 'highpass' else: filter = 'lowpass' else: order = self.ord #---------------------------------------------------------------------- _sos = butter(order, _wp, btype=filter, output='sos') a, b = np.zeros([len(_sos), 3]), np.zeros([len(_sos), 3]) #---------------------------------------------------------------------- for i in range(len(_sos)): a[i] = _sos[i][3:] b[i] = _sos[i][:3] self.sos.append(np.zeros(len(a))) self.sos[self.flag] = [__sos__(a[i], b[i]) for i in range(len(a))] self.flag += 1 return None
def __init__(self): # オーディオに関する設定 self.p = pyaudio.PyAudio() self.channels = 1 # マイクがモノラルの場合は1にしないといけない self.rate = 16000 #48000 # DVDレベルなので重かったら16000にする self.CHUNK = 2**11 self.format = pyaudio.paInt16 self.stream = self.p.open(format=self.format, channels=self.channels, rate=self.rate, frames_per_buffer=self.CHUNK, output=True, input=True, stream_callback=self.callback, input_device_index=4) self.ndarray = np.array([]) self.alldata = np.array([]) self.cnt = -1 self.fpass = 1.0 * 10**2 # 通過遮断周波数[Hz] self.fstop = 1.0 * 10**3 # 阻止域遮断周波数[Hz] self.gpass = 0.4 # 通過域最大損失量[dB] self.gstop = 30 # 阻止域最小減衰量[dB] #正規化 self.fn = self.rate / 2 self.wp = self.fpass / self.fn self.ws = self.fstop / self.fn #フィルタの係数設計(バタワースフィルタ) self.N, self.Wn = signal.buttord(self.wp, self.ws, self.gpass, self.gstop) #オーダーとバターワースの正規化周波数を計算 self.b, self.a = signal.butter(self.N, self.Wn, "highpass") #フィルタ伝達関数の分子と分母を計算
def low_pass_filter(signal, fs, end_freq): """ Description - Low Pass Filter Input :param signal:list, 입력 신호 :param fs: Float, 샘플링 주파수 (sampling frequency) :param end_freq: Float, 끝 주파수 (passband) Output :return list, 필터링된 신호 Example: >>> signal = [0, 1, 2, 3, 2, 1, 0, -1, -2, -3, -2, -1] >>> fs = 0.1 >>> end_freq = 0.02 >>> low_pass_filter(signal, fs, end_freq) array([-7.04764275e-05, 1.06577490e+00, 2.14355722e+00, 2.64998306e+00, 2.14375040e+00, 1.06552842e+00, -1.00019323e-03, -1.06409485e+00, -2.13795954e+00, -2.66057414e+00, -2.17495858e+00, -9.99904965e-01]) """ n, wn = buttord(2 * end_freq / fs, 4 * end_freq / fs, 1, 10) # 'Butterworth Filter'의 차수(order) 구하기 b, a = butter(n, wn, btype='low') # 'Butterworth Filter'의 a와 b 파라메터 생성 sos = tf2sos(b, a) # 2차수(order) 필터 계수의 배열 구하기 signal = np.array(signal).reshape(-1) # 1차원 리스트가 아닌 경우를 위해 1차원으로 변환 filtered_signal = sosfiltfilt(sos, signal) # A forward-backward digital filter using cascaded second-order sections. return filtered_signal
def high_pass_filter(signal, fs, start_freq, start_stop_freq): """ Description - High Pass Filter Input :param signal:list, 입력 신호 :param fs: Float, 샘플링 주파수 (sampling frequency) :param start_freq: Float, 시작 주파수 (passband) :param start_stop_freq: Float, 시작 주파수의 여유 (stopband) Output :return list, 필터링된 신호 Example >>> signal = [0, 1, 2, 3, 2, 1, 0, -1, -2, -3, -2, -1] >>> fs = 0.1 >>> start_freq = 0.02 >>> start_stop_freq = 0.03 >>> high_pass_filter(signal, fs, start_freq, start_stop_freq) array([ 0. , 0.02923319, -0.12894364, 0.17272625, -0.05544299, 0.11883306, -0.36247096, 0.09681751, 0.32750824, -0.02172602, -0.20884044, -0.34628683]) """ n, wn = buttord(start_freq / fs * 2, start_stop_freq / fs * 2, 3, 40) # 'Butterworth Filter'의 차수(order) 구하기 b, a = butter(n, wn, btype='high') # 'Butterworth Filter'의 a와 b 파라메터 생성 filtered_signal = lfilter(b, a, signal, axis=0) # A forward-backward digital filter using cascaded second-order sections. return filtered_signal
def onWsChange(self, ws): self.ws = ws / 10 n1, wn1 = sig.buttord(self.wp, self.ws, self.alphap, self.alphas) B, A = sig.butter(n1, wn1) w2, h2 = sig.freqz(B, A, 1000) self.p1.setData(w2, np.abs(h2)) self.wsBox.setValue(self.ws)
def filter_FMC(self,lowcut,highcut): # Backwards compatibility stuff: if not hasattr(self, 'Filtered'): self.Filtered = False if self.Filtered: self.Unpacked=False # Design filter with parameters... pass_stop_width = 0.8 nyq = 0.5 * self.Fs low = lowcut / nyq high = highcut / nyq order = buttord([low, high],[low*pass_stop_width, high*(2-pass_stop_width)],3,30) print('Designing filter with order {}'.format(order[0])) b, a = butter(order[0], [low, high], btype='band') # Apply filter to FMC FMC = self.get_FMC() n_scans = FMC.shape[0] for idx in range(n_scans): a_scan = FMC[idx,:] a_scan = filtfilt(b, a, a_scan) FMC[idx,:] = a_scan self.FMC = FMC self.Filtered=True
def _LP_Butterworth(interval, sampling_rate, cutoff, order=5): nyq = sampling_rate * 0.5 stopfreq = float(cutoff) cornerfreq = 0.5 * stopfreq Ws = stopfreq / nyq Wp = cornerfreq / nyq N, Wn = buttord(Wp, Ws, 3, 20) # (?) print "The oder of LPF is: %f" % N """ Wp = 2 * np.pi * 100 Ws = 2 * np.pi * 20 Rp = 1.5 Rs = 20 N, Wn = buttord(Wp, Ws, Rp, Rs) # (?) """ # for hardcoded order: # N = order b, a = butter(N, Wn, btype="low") # should 'high' be here for bandpass? # b, a = butter(9, float(20.0/nyq) , btype='high') # should 'high' be here for bandpass? sf = lfilter(b, a, interval) return sf, b, a
def onAlphapChange(self, alphap): self.alphap = alphap n1, wn1 = sig.buttord(self.wp, self.ws, self.alphap, self.alphas) B, A = sig.butter(n1, wn1) w2, h2 = sig.freqz(B, A, 1000) self.p1.setData(w2, np.abs(h2)) self.alphapBox.setValue(self.alphap)
def get_filter(spec, filter_type='but', method='zoh'): if filter_type.lower() in ('butterworth'): N, Wn = signal.buttord(2*np.pi*spec['fp'], 2*np.pi*spec['fs'], spec['Amax'], spec['Amin'], analog=True) z, p, k = signal.butter(N, Wn, output='zpk', btype='low', analog=True) elif filter_type.lower() in ('cauer' + 'elliptic'): N, Wn = signal.ellipord(2*np.pi*fp, 2*np.pi*spec['fs'], spec['Amax'], spec['Amin'], analog=True) z, p, k = signal.ellip(N, spec['Amax'], spec['Amin'], Wn, output='zpk', btype='low', analog=True) def matched_method(z, p, k, dt): zd = np.exp(z*dt) pd = np.exp(p*dt) kd = k * np.abs(np.prod(1-pd)/np.prod(1-zd) * np.prod(z)/np.prod(p)) return zd, pd, kd, dt if method == 'matched': zd, pd, kd, dt = matched_method(z, p, k, spec['dt']) kd *= 1 - (1 - 10 ** (-spec['Amax']/20))/2 else: zd, pd, kd, dt = signal.cont2discrete((z,p,k), spec['dt'], method=method) analog_system = (z,p,k) discrete_system = (zd,pd,kd) return analog_system, discrete_system
def power_line_filter(data, Fs): N, Wn = signal.buttord(wp=[48 / Fs, 53 / Fs], ws=[46 / Fs, 55 / Fs], gpass=0.1, gstop=10.0, analog=False) b, a = signal.butter(N, Wn, 'bandstop', False) w, h = signal.freqz(b, a) fig = plt.figure() plt.title('Digital filter frequency response') ax1 = fig.add_subplot(111) plt.plot(w, 20 * np.log10(abs(h)), 'b') plt.ylabel('Amplitude [dB]', color='b') plt.xlabel('Frequency [rad/sample]') ax2 = ax1.twinx() angles = np.unwrap(np.angle(h)) plt.plot(w, angles, 'g') plt.ylabel('Angle (radians)', color='g') plt.grid() plt.axis('tight') # plt.show() y = signal.lfilter(b, a, data) return y
def besselord(omega_p, omega_s, alfa_max, alfa_min, omega_d, max_pc_delay): min_order = 0 # partimos de suponer que al menos será el orden de un Butter o más grande start_order, _ = sig.buttord(omega_p, omega_s, alfa_max, alfa_min + alfa_max, analog=True) # de forma iterativa, intentamos cumplimentar la plantilla for ii in range(start_order, 20): z, p, k = sig.besselap(ii, norm='delay') this_lti = sig.ZerosPolesGain(z, p, k).to_tf() _, mm, pp = sig.bode(this_lti, w=[0, 0.0001, omega_p, omega_d, omega_d + 0.0001]) # attenuation in omega_p, i.e. bandpass end this_ripple = -mm[2] # relative delay this_delay = 1 - np.abs((pp[4] - pp[3]) / (pp[1] - pp[0])) if this_ripple <= alfa_max and this_delay <= max_pc_delay: break min_order = ii return min_order
def lpf(fs, wave, cutoff): WP = float(cutoff) / float(fs / 2) WS = 1.3 * WP N, Wn = sg.buttord(wp=WP, ws=WS, gpass=2, gstop=30, analog=0) b, a = sg.butter(N, Wn, btype='low', analog=0, output='ba') g = sg.lfilter(b, a, wave) return g
def get_filter(spec, filter_type='but', method='zoh'): wp = 2*np.pi*spec['fp'] ws = 2*np.pi*spec['fs'] if method == 'bilinear': wp = 2/spec['dt'] * np.arctan(wp * spec['dt']/2) ws = 2/spec['dt'] * np.arctan(ws * spec['dt']/2) if filter_type.lower() in ('butterworth'): N, Wn = signal.buttord(wp, ws, spec['Amax'], spec['Amin'], analog=True) z, p, k = signal.butter(N, Wn, output='zpk', btype='low', analog=True) elif filter_type.lower() in ('cauer' + 'elliptic'): N, Wn = signal.ellipord(wp, ws, spec['Amax'], spec['Amin'], analog=True) z, p, k = signal.ellip(N, spec['Amax'], spec['Amin'], Wn, output='zpk', btype='low', analog=True) if method == 'matched': zd, pd, kd, dt = matched_method(z, p, k, spec['dt']) kd *= 1 - (1 - 10 ** (-spec['Amax']/20))/2 else: zd, pd, kd, dt = signal.cont2discrete((z,p,k), spec['dt'], method=method) analog_system = (z,p,k) discrete_system = (zd,pd,kd) return analog_system, discrete_system
def butter_lowpass(fr, step, arr, fps=250): #N, Wn = signal.buttord(1./(1.*fps/step),1./fps, 1/step, fps*0.5) N, Wn = buttord(fr/step, fr, 1/step, fps*0.5 ,0.5/fps) b, a = butter(N, Wn,'low') y = filtfilt(b, a, arr) return y
def low_pass_filter(self, fp, fs, g_pass, g_stop): ''' Butterworth filter (low pass) https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.butter.html https://watlab-blog.com/2019/04/30/scipy-lowpass/ ''' samples = np.array(self.audio.get_array_of_samples()) channels = self.audio.channels frame_rate = self.audio.frame_rate # print(f'samples dim: {samples.ndim} / shape: {samples.shape}\nchannels: {channels}\nfame_rate: {frame_rate}') fn = frame_rate / 2 wp = fp / fn ws = fs / fn N, Wn = signal.buttord(wp, ws, g_pass, g_stop) b, a = signal.butter(N, Wn, 'low') sample_res = np.zeros(samples.shape[0], dtype=np.float64) for i in range(channels): sample_m = samples[i::channels] sample_res[i::channels] = signal.filtfilt( b, a, sample_m) # チャンネルごとにフィルタを適用 # print(samples[1000000:1000010]) # print(sample_res[1000000:1000010]) # print(f'samples dim: {samples.ndim} / shape: {sample_res.shape}\nwidth: {self.audio.sample_width}') res = AudioSegment( sample_res.astype(np.int16).tobytes(), sample_width=self.audio.sample_width, frame_rate=frame_rate, channels=channels, ) return res
def makefiltersos(sr,fp,fs,gp=3,gs=20): """ Wrapper function around scipy filter functions. Makes it convenient by providing frequency parameters in terms of frequencies in Hz. INPUT: sr - sampling rate in Hz. fp - pass frequency in Hz fs - stop frequency in Hz gp - pass band ripple in dB, default 3 dB gs - stop band attenuation in dB, default 20 dB doPlot - make a plot of filter gain versus frequency, default 'no' OUTPUT: sos filter coefficients. w,h for making bode plot Automatically detects the type of filter. if fp < fs the filter is low pass but if fp > fs the filter is highpass. """ # #set up filter parameters fn = sr/2 wp = fp/fn ws = fs/fn #get the filter order n,wn = signal.buttord(wp,ws,gp,gs); #design the filter #lowpass if fp < fs: sos = signal.butter(n,wn,btype='lowpass',output='sos') #highpass if fs < fp: sos = signal.butter(n,wn,btype='highpass',output='sos') #get filter respons function w,h = signal.sosfreqz(sos,fs=sr) return sos,w,h
def noise_removal_cheat(source_image, npy=True, show=False): if npy: source_image = np.load(source_image) Fp = 650 Fc = 750 Fe = 1600 order, Wn = signal.buttord(2 * Fp / Fe, 2 * Fc / Fe, gpass=0.5, gstop=40) print(order) #order = 2 b, a, *_ = signal.butter(order, Wn) if show: plt.figure() x, y = signal.freqz(b, a) plt.plot(x, 20 * np.log10(abs(y))) plt.title("Gain de la réponse en fréquence") plt.xlabel("Multiple fréquence gauchie (pi)") plt.ylabel("Gain (dB)") plt.show() print(a) print(b) zplane.zplane(b, a) output = signal.lfilter(b, a, source_image) if show: plt.figure() plt.title('Image débruitée - méthode butterworth') plt.imshow(output, cmap='gray') plt.show() return output
def lpf(f, cutoff): WP = float(cutoff) / float(Fs / 2) WS = 1.3 * WP N, Wn = buttord(wp=WP, ws=WS, gpass=2, gstop=30, analog=0) b, a = butter(N, Wn, btype='low', analog=0, output='ba') g = lfilter(b, a, f) return g
def prob3a(): Fe = 48000 wp = 2500 / (Fe / 2) ws = 3500 / (Fe / 2) gpass = 0.2 gstop = 40 print(wp, ws) order, wn = signal.buttord(wp, ws, gpass, gstop, False, Fe) num, denum = signal.butter(order, wn, 'lowpass', False, output='ba') print(order) w, Hw = signal.freqz(num, denum) plt.figure() plt.plot(w * Fe / (2 * pi), dB(np.abs(Hw))) # En frequences plt.title('Butter') num, denum, k = signal.butter(order, wn, 'lowpass', False) plt.figure() zplane(num, denum) print(k)
def _build_lpfilter(self, fs): """ builds low-pass filter with a cutoff frequency of 3/7th the resample frequency. The filter should be down 40 dB at 1.5 times the cutoff frequency (6/7th) the resample frequency. Parameters ---------- fs : the base sampling rate Returns ------- b, a : array_like Numerator (b) and denominator (a) polynomials of the IIR filter. """ nyq = fs/2. # nyquist frequency cutoff = (3./7.)*self.resample_fs # cutoff freq defined by Boer wp = cutoff * nyq # pass edge freq (pi radians / sample) ws = wp*2. # pass edge freq (pi radians / sample) gpass = 1.5 # The maximum loss in the passband (dB) gstop = 40 # The minimum attenuation in the stopband (dB) n, wn = buttord(wp, ws, gpass, gstop) #print('n =',n,'wn =',wn) b, a = butter(n, wn, analog=True) return b, a
def test_buttord_2(self): # Test case for highpass filter self.assertTrue( np.all( IIRDesign.buttord(self.f2, self.f1, self.Rp, self.Rs) == signal.buttord( self.f2, self.f1, self.Rp, self.Rs, analog=False, fs=2)))
def HPmin(self, fil_dict): self._get_params(fil_dict) self.N, self.F_PBC = buttord(self.F_PB,self.F_SB, self.A_PB,self.A_SB) if not self._test_N(): return -1 self._save(fil_dict, sig.bessel(self.N, self.F_PBC, btype='highpass', analog=False, output=self.FRMT))
def data_hpass(self, x, Wp, srate): ''' High-pass filter ''' Wp = float(Wp*2/srate) Ws = Wp*float(self.lineEdit_19.text()) Rp = float(self.lineEdit_17.text()) Rs = float(self.lineEdit_18.text()) tempstring = self.lineEdit_16.text() if tempstring == 'auto': if self.comboBox_2.currentIndex() == 0: (norder, Wn) = buttord(Wp, Ws, Rp, Rs) elif self.comboBox_2.currentIndex() == 1: (norder, Wn) = ellipord(Wp, Ws, Rp, Rs) else: (norder, Wn) = cheb1ord(Wp, Ws, Rp, Rs) else: norder = float(tempstring) Wn = Wp if self.comboBox_2.currentIndex() == 0: (b, a) = butter(norder, Wn, btype = 'high') elif self.comboBox_2.currentIndex() == 1: (b, a) = ellip(norder, Rp, Rs, Wn) else: (b, a) = cheby1(norder, Rp, Wn) y = filtfilt(b, a, x) return(y)
def signal(self, fs, atten, caldb, calv): npts = self._duration*fs # start with full spectrum white noise and band-pass to get desired # frequency range signal = self._noise[:npts] # band frequency cutoffs delta = 10**(3./(10.*(2*self._width))) low_freq = self._center_frequency / delta high_freq = self._center_frequency * delta # scipy butter function wants frequencies normalized between 0. and 1. nyquist = fs/2. low_normed = low_freq / nyquist high_normed = high_freq / nyquist order, wn = buttord([low_normed, high_normed], [low_normed-0.05, high_normed+0.05], 1, 40) # print 'CUTOFFS', low_freq, high_freq # print 'ORDER WN', order, wn, low_normed, high_normed b, a = butter(order, wn, btype='band') signal = lfilter(b, a, signal) if self._risefall > 0: rf_npts = int(self._risefall * fs) / 2 wnd = hann(rf_npts*2) # cosine taper signal[:rf_npts] = signal[:rf_npts] * wnd[:rf_npts] signal[-rf_npts:] = signal[-rf_npts:] * wnd[rf_npts:] return signal
def remove_tides(cube, T=T_M2): time_coord = cube.coord('time') time_units = time_coord.units target_units = cf_units.Unit( 'seconds since 1970-01-01 00:00:00-00', calendar='gregorian' ) time = time_units.convert(time_coord.points, target_units) dt = numpy.diff(time) # assert (dt.max() - dt.min()) < 1e-3, 'Uneven dt is not supported' dt = dt.min() # filter design, low-pass butterworth T0 = (2 * dt) # period of Nyquist frequency Tpass = 8 * T # period of pass frequency Gpass = 3.0 # max dB loss in pass band Tstop = 1 * T # period of stop frequency Gstop = 30.0 # min dB atennuation in stop band o, Wn = signal.buttord(T0 / Tpass, T0 / Tstop, Gpass, Gstop) if o < 0: raise Exception( 'Cannot create tidal filter. Data sampling frequency may be too low, dt=' + str(dt)) sos = signal.butter(o, Wn, output='sos') data_filtered = signal.sosfiltfilt(sos, cube.data) new_cube = cube.copy() new_cube.data = data_filtered return new_cube
def psd(y): # Number of samplepoints N = 128 # sample spacing T = 1.0 / 128.0 # From 0 to N, N*T, 2 points. #x = np.linspace(0.0, 1.0, N) #y = 1*np.sin(10.0 * 2.0*np.pi*x) + 9*np.sin(20.0 * 2.0*np.pi*x) fs = 128.0 fso2 = fs/2 Nd,wn = buttord(wp=[9/fso2,11/fso2], ws=[8/fso2,12/fso2], gpass=3.0, gstop=40.0) b,a = butter(Nd,wn,'band') y = filtfilt(b,a,y) yf = fft(y) #xf = np.linspace(0.0, 1.0/(2.0*T), N/2) #import matplotlib.pyplot as plt #plt.plot(xf, 2.0/N * np.abs(yf[0:N/2])) #plt.axis((0,60,0,1)) #plt.grid() #plt.show() return np.sum(np.abs(yf[0:N/2]))
def lpf(m): cutoff = 9000 norm_pass = cutoff/(m.fs/2) (N, Wn) = signal.buttord(wp=norm_pass, ws=1.5*norm_pass, gpass=2, gstop=50, analog=0) (b, a) = signal.butter(N, Wn, btype='lowpass', analog=0, output='ba') m.msg = signal.lfilter(b, a, m.msg) m.msg *= 1.0/np.abs(m.msg).max() return m
def BSmin(self, fil_dict): self._get_params(fil_dict) self.N, self.F_PBC = buttord([self.F_PB, self.F_PB2], [self.F_SB, self.F_SB2], self.A_PB,self.A_SB, analog = self.analog) if not self._test_N(): return -1 self._save(fil_dict, sig.butter(self.N, self.F_PBC, btype='bandstop', analog=self.analog, output=self.FRMT))
def set_lowPass_filter(self, wp=20., ws=40., gpass=1., gstop=10.): Nq = self.fs / 2. wp, ws = float(wp) / Nq, float(ws) / Nq gpass, gstop = float(gpass), float(gstop) N_filtr, Wn_filtr = buttord(wp, ws, gpass, gstop) self.b_L, self.a_L = butter(N_filtr, Wn_filtr, btype='low') self.N_L, self.Wn_L = N_filtr, Wn_filtr
def setOrderAndCritFreq(self, wp, ws, maxBand, minBand): self.__orderFiltr, self.__criticalFrequency = signal.buttord( wp=wp, ws=ws, gpass=minBand, gstop=maxBand, analog=False, fs=self.__samplingFrequency)
def set_lowPass_filter(self, wp=20., ws=40., gpass=1., gstop=10.): Nq = self.fs/2. wp, ws = float(wp)/Nq, float(ws)/Nq gpass, gstop = float(gpass), float(gstop) N_filtr, Wn_filtr = buttord(wp, ws, gpass, gstop) self.b_L, self.a_L = butter(N_filtr, Wn_filtr, btype='low') self.N_L, self.Wn_L = N_filtr, Wn_filtr
def data_lpass(self, x, Wp, srate): ''' Low-pass filter using various filter type ''' tempstring = self.lineEdit_16.text() if tempstring == 'auto': Wp = float(Wp*2/srate) Ws = Wp*float(self.lineEdit_19.text()) Rp = float(self.lineEdit_17.text()) Rs = float(self.lineEdit_18.text()) if self.comboBox_2.currentIndex() == 0: (norder, Wn) = buttord(Wp, Ws, Rp, Rs) elif self.comboBox_2.currentIndex() == 1: (norder, Wn) = ellipord(Wp, Ws, Rp, Rs) else: (norder, Wn) = cheb1ord(Wp, Ws, Rp, Rs) else: norder = float(tempstring) Wp = float(Wp*2/srate) Ws = Wp*2 self.lineEdit_19.setText(str(Ws/Wp)) Rp = 3 self.lineEdit_17.setText(str(Rp)) Rs = 0.3*norder*20 self.lineEdit_18.setText(str(Rs)) if self.comboBox_2.currentIndex() == 0: (norder, Wn) = buttord(Wp, Ws, Rp, Rs) elif self.comboBox_2.currentIndex() == 1: (norder, Wn) = ellipord(Wp, Ws, Rp, Rs) else: (norder, Wn) = cheb1ord(Wp, Ws, Rp, Rs) if self.comboBox_2.currentIndex() == 0: (b, a) = butter(norder, Wn) elif self.comboBox_2.currentIndex() == 1: (b, a) = ellip(norder, Rp, Rs, Wn) else: (b, a) = cheby1(norder, Rp, Wn) y = filtfilt(b, a, x) return(y)
def smooth(time, vals, dt=None, gapFactor=20, T=T_M2): from scipy import signal if dt is None: dt = np.diff(time).mean() ta = timeArray.timeArray(time, 'epoch') # try to calculate exact dt by omitting large gaps gaps, ranges, t = ta.detectGaps(dt=dt, gapFactor=gapFactor) diff = [] for i in range(ranges.shape[0]): twin = time[ranges[i, 0]:ranges[i, 1]] diff.append(np.diff(twin)) diff = np.concatenate(tuple(diff), axis=0) dt = diff.mean() # filter design, low-pass butterworth T0 = (2 * dt) # period of Nyquist frequency Tpass = 8 * T # period of pass frequency Gpass = 3.0 # max dB loss in pass band Tstop = 1 * T # period of stop frequency Gstop = 30.0 # min dB atennuation in stop band o, Wn = signal.buttord(T0 / Tpass, T0 / Tstop, Gpass, Gstop) if o < 0: raise Exception( 'Cannot create tidal filter. Data sampling frequency may be too low, dt=' + str(dt)) b, a = signal.butter(o, Wn, 'low') newvals = [] newtime = [] # filter each contiquous data range separately for i in range(ranges.shape[0]): twin = time[ranges[i, 0]:ranges[i, 1]] vwin = vals[ranges[i, 0]:ranges[i, 1]] if len(vwin) > 3 * len(a): try: # default forward-backward filter # filtered = signal.filtfilt(b, a, vwin, padtype='constant') # forward-backward filter with custom boundary conditions # pad with mean of 1/2 pass window lenght N_init = int(np.ceil(Tpass / dt / 2 / 4)) # forward filter x_init = vwin[:N_init] y_init = x_init.mean() * np.ones_like(x_init) z_init = signal.lfiltic(b, a, y_init, x_init) filtered, _ = signal.lfilter(b, a, vwin, zi=z_init) # backward filter x_init = vwin[-N_init:][::-1] y_init = x_init.mean() * np.ones_like(x_init) z_init = signal.lfiltic(b, a, y_init, x_init) filtered, _ = signal.lfilter(b, a, filtered[::-1], zi=z_init) filtered = filtered[::-1] newvals.append(filtered) newtime.append(twin) except Exception as e: print a.shape, vwin.shape raise e newvals = np.concatenate(tuple(newvals), axis=0) newtime = np.concatenate(tuple(newtime), axis=0) return newtime, newvals
def butter_bandpass(filt_freq,fs): nyq = 0.5 * fs wp=[filt_freq[1]/nyq, filt_freq[2]/nyq, ] ws=[filt_freq[0]/nyq, filt_freq[3]/nyq] N, wn = buttord(wp, ws, 3, 16) print N b, a = butter(N, wn, btype='band') return b, a
def compute_parameters(self, target='stopband'): """ This function computes the order and the -3 dB-frequency of the filter for the specific parameters. Arguments: target: The optimization goal for the filter computation. Choices are: - stopband: optimize to the stopband (like MATLAB) - passband: optimize to the passband """ if target not in ['passband', 'stopband', None]: raise ValueError("Target must be one of passband or stopband, \ or not given if filter is not Butterworth.") else: self.filter_target = target if True: # Change here to be more verbose. print("Ws = ", self.Ws) print("Wp = ", self.Wp) print("Rp = ", self.passband_attenuation) print("Rs = ", self.stopband_attenuation) if self.filter_class == 'butterworth': if target == 'passband': self.N, self.Wn = signal.buttord(self.Wp, self.Ws, self.passband_attenuation, self.stopband_attenuation, analog=True) elif target == 'stopband': self.N, self.Wn = custom.custom_buttord(self.Wp, self.Ws, self.passband_attenuation, self.stopband_attenuation, analog=True) else: raise ValueError("Butterworth filters must match either the \ passband or the stopband.") elif self.filter_class == 'chebyshev_1': self.N, self.Wn = signal.cheb1ord(self.Wp, self.Ws, self.passband_attenuation, self.stopband_attenuation, analog=True) elif self.filter_class == 'chebyshev_2': self.N, self.Wn = signal.cheb2ord(self.Wp, self.Ws, self.passband_attenuation, self.stopband_attenuation, analog=True) elif self.filter_class == 'elliptical': self.N, self.Wn = signal.ellipord(self.Wp, self.Ws, self.passband_attenuation, self.stopband_attenuation, analog=True) else: raise NotImplementedError( "Filter family {} not yet implemented".format(self.filter_class)) pass
def highpass(s,stopBand,fs): ''' highpass signal for noise reduction finch songdata should be in range 350Hz to 11kHz ''' N,wn = ss.buttord(wp=2*np.pi*(stopBand+100.)/fs,ws=2*np.pi*stopBand*1.0/fs,gpass=2.0, gstop=30.0,analog=0) b, a = ss.butter(N, wn,btype='high',analog=0) filteredsong = ss.lfilter(b, a, s) filteredsong = np.round(filteredsong).astype('int16') # scipy wav needs 16 bit depth return filteredsong
def ex4_1(): wp = 0.2*np.pi ws = 0.3*np.pi fs = 4000.0 T = 1/fs Wp = wp/T Ws = ws/T n, x = signal.buttord(Wp, Ws, 2, 40, analog=True) b, a = signal.butter(n, x, analog=True) z, p, k = signal.tf2zpk(b, a) print z, p, k
def calculate_bandpass(self): # Bandpass filter #self.width = 10000.0/self.nyquist_rate #self.cutoff = 2000.0/self.nyquist_rate self.ripple_db = 60.0 self.high_pass = (self.tx_freq+1000.0)/self.nyquist_rate self.low_pass = (self.tx_freq-1000.0)/self.nyquist_rate self.high_cutoff = (self.tx_freq+1500.0)/self.nyquist_rate self.low_cutoff = (self.tx_freq-1500.0)/self.nyquist_rate ord, wn = signal.buttord([self.low_pass, self.high_pass],[self.low_cutoff,self.high_cutoff],1.0,30.0) self.b,self.a = signal.butter(ord,wn, btype="band")
def bandpass(self, flow, fhigh, gpass=2, gstop=30, stops=(None, None)): """Filter this `TimeSeries` by applying low- and high-pass filters. Parameters ---------- flow : `float` band-pass lower corner frequency fhigh : `float` band-pass upper corner frequency gpass : `float` the maximum loss in the pass band (dB). gstop : `float` the minimum attenuation in the stop band (dB). stops: 2-`tuple` of `float` stop-band edge frequencies, defaults to `[flow/2., fhigh*1.5]` Returns ------- bpseries : `TimeSeries` a band-passed version of the input `TimeSeries` See Also -------- scipy.signal.buttord scipy.signal.butter for details on how the filter is designed TimeSeries.filter for details on how the filter is applied .. note:: When using `scipy < 0.16.0` some higher-order filters may be unstable. With `scipy >= 0.16.0` higher-order filters are decomposed into second-order-sections, and so are much more stable. """ nyq = self.sample_rate.value / 2. if stops is None: stops = [None, None] stops = list(stops) if stops[0] is None: stops[0] = flow * 0.5 if stops[1] is None: stops[1] = fhigh * 1.5 # make sure all are in Hertz low = units.Quantity(flow, 'Hz').value / nyq high = units.Quantity(fhigh, 'Hz').value / nyq stops = [units.Quantity(s, 'Hz').value / nyq for s in stops] # design filter order, wn = signal.buttord(wp=[low, high], ws=stops, gpass=gpass, gstop=gstop, analog=False) zpk = signal.butter(order, wn, btype='band', analog=False, output='zpk') # apply filter return self.filter(*zpk)
def __call__(self, t, data): dt = t[1]-t[0] Fs = 1.0/dt Nyq = Fs/2.0 Wp = self.cf/Nyq Ws = self.sf/Nyq [n,Wn] = buttord(Wp,Ws,self.rp, self.rs) [b,a] = butter(n,Wn) data = lfilter(b,a,data) return data
def lowPass(samp_rate, cutoff, inputArray): # design filter norm_pass = cutoff/(samp_rate/2) norm_stop = 1.5*norm_pass (N, Wn) = signal.buttord(wp=norm_pass, ws=norm_stop, gpass=2, gstop=30, analog=0) (b, a) = signal.butter(N, Wn, btype='low', analog=0, output='ba') # filtered output #zi = signal.lfiltic(b, a, x[0:5], x[0:5]) #(y, zi) = signal.lfilter(b, a, x, zi=zi) return signal.lfilter(b, a, inputArray, axis=0)
def _NOTCH_butter_bandstop(interval, sampling_rate, cutoff, order=5): nyq = sampling_rate * 0.5 stopfreq = float(cutoff) + 300.0 cornerfreq = float(cutoff) - 300.0 Ws = stopfreq / nyq Wp = cornerfreq / nyq N, Wn = buttord(Wp, Ws, 8, 20) # (?) print N, Wn, Wp, Ws, stopfreq, cornerfreq b, a = butter(N, [Wp, Ws], btype="bandstop") # should 'high' be here for bandpass? sf = lfilter(b, a, interval) return sf, b, a
def main(): # play with these values cutoff = 9000 norm_pass = cutoff/(44100/2) (N, Wn) = signal.buttord(wp=norm_pass, ws=1.5*norm_pass, gpass=2, gstop=50, analog=0) (b, a) = signal.butter(N, Wn, btype='lowpass', analog=0, output='ba') w, h = signal.freqz(b, a) plot.figure() plot.title("Digital Filter Frequency Response") plot.plot(w/2/np.pi*44100, 20 * np.log10(abs(h))) plot.xlabel("Frequency (Hz)") plot.ylabel("Gain (dB)") plot.show()
def _HP_Butterworth(interval, sampling_rate, cutoff): nyq = sampling_rate * 0.5 stopfreq = float(cutoff) cornerfreq = 0.5 * stopfreq Ws = cornerfreq / nyq Wp = stopfreq / nyq # N, Wn = buttord(Wp, Ws, 3, 20) # (?) # N, Wn = buttord(Wp, Ws, 6, 20) # (?) N, Wn = buttord(Wp, Ws, 10, 27) # (?) print "The oder of HPF is: %f" % N b, a = butter(N, Wn, btype="high") # should 'high' be here for bandpass? # b, a = butter(9, float(20.0/nyq) , btype='high') # should 'high' be here for bandpass? sf = lfilter(b, a, interval) return sf, b, a
def highpass(self, frequency, gpass=2, gstop=30, stop=None): """Filter this `TimeSeries` with a Butterworth high-pass filter. Parameters ---------- frequency : `float` minimum frequency for high-pass gpass : `float` the maximum loss in the passband (dB). gstop : `float` the minimum attenuation in the stopband (dB). stop : `float` stop-band edge frequency, defaults to `frequency/2` Returns ------- hpseries : `TimeSeries` a high-passed version of the input `TimeSeries` See Also -------- scipy.signal.buttord scipy.signal.butter for details on how the filter is designed TimeSeries.filter for details on how the filter is applied .. note:: When using `scipy < 0.16.0` some higher-order filters may be unstable. With `scipy >= 0.16.0` higher-order filters are decomposed into second-order-sections, and so are much more stable. """ nyq = self.sample_rate.value / 2. if stop is None: stop = .5 * frequency # convert to float in Hertz cutoff = units.Quantity(frequency, 'Hz').value / nyq stop = units.Quantity(stop, 'Hz').value / nyq # design filter order, wn = signal.buttord(wp=cutoff, ws=stop, gpass=gpass, gstop=gstop, analog=False) zpk = signal.butter(order, wn, btype='high', analog=False, output='zpk') # apply filter return self.filter(*zpk)
def _compute_parameters(self): normalized_pb, normalized_sb = self.normalized_pb_sb() self.already_normalized_Wn = True if self.target == 'passband': self.N, self.Wn = signal.buttord(normalized_pb, normalized_sb, self.filter_parameters['passband_attenuation'], self.filter_parameters['stopband_attenuation'], analog=False) elif self.target == 'stopband': # Match stopband (like MATLAB) self.N, self.Wn = custom.custom_buttord(normalized_pb, normalized_sb, self.filter_parameters['passband_attenuation'], self.filter_parameters['stopband_attenuation'], analog=False) else: raise ValueError("Butterworth filters must match or the passband\ or the stopband.")
def bandpass(data, dt, lo, hi): ''' Filter the data so that energy outside of pass band is attenuated data -- real data sampled at dt dt -- time between data samples lo -- low freq cuttoff hi -- hi freq cuttoff ''' BW = 1/(2 * dt) wp = (lo / BW, hi/BW) ws = (lo * .4/BW, hi * 1.4 / BW) gpass = 1 gstop = 20 N, Wn = signal.buttord(wp, ws, gpass, gstop) # b, a = signal.butter(N, Wn, btype='bandpass') b, a = signal.butter(5, Wn, btype='bandpass') return signal.lfilter(b, a, data)
def hilbert_transform(data,bandpass=[25,40],Fs=1000): '''data input as time x samples''' #bandpass=[25,40] #Fs=1000 upper = bandpass[1]/float(Fs/2) lower = bandpass[0]/float(Fs/2) order,wn = scisig.buttord([lower, upper],[np.max([0, lower-0.01]), np.min([upper+0.01, 1])],3,20) b, a = scisig.butter(np.min([order,9]), wn, btype = 'bandpass') amp = np.zeros((data.shape[0],data.shape[1])) phase = np.zeros((data.shape[0],data.shape[1])) for i, d in enumerate(data.T): y = scisig.filtfilt(b,a,d) z = scisig.hilbert(y) amp[:,i] = abs(z) phase[:,i] = phz(z) return amp, phase