def _design(self): if not self.ripple and 'ripple' in self.filter_parameters: self.ripple = self.filter_parameters['ripple'] elif not self.ripple and 'ripple' not in self.filter_parameters: raise ValueError("Needs a ripple value.") if self.already_normalized_Wn: self.Z, self.P, self.K = signal.cheby1(self.N, self.ripple, self.Wn, self.filter_kind, analog=False, output='zpk') else: self.Z, self.P, self.K = signal.cheby1(self.N, self.ripple, self.normalize_Wn(), self.filter_kind, analog=False, output='zpk')
def decimate_coeffs(q, n=None, ftype='iir'): q = int(q) if n is None: if ftype == 'fir': n = 30 else: n = 8 if ftype == 'fir': coeffs = GlobalVars.decimate_fir_coeffs if (n, 1./q) not in coeffs: coeffs[n, 1./q] = signal.firwin(n+1, 1./q, window='hamming') b = coeffs[n, 1./q] return b, [1.], n else: coeffs = GlobalVars.decimate_iir_coeffs if (n, 0.05, 0.8/q) not in coeffs: coeffs[n, 0.05, 0.8/q] = signal.cheby1(n, 0.05, 0.8/q) b, a = coeffs[n, 0.05, 0.8/q] return b, a, n
def bandpass(x, y): cutoff1 = int(x) cutoff2 = int(y) fs = 48000 Wn = [cutoff1/(fs/2), cutoff2/(fs/2)] b, a = signal.cheby1(1, 1, Wn, 'bandpass', analog=False) return b, a
def test_decimate(): from numpy import arange,sin from scipy.signal import decimate, resample, cheby1, lfilter, filtfilt t = arange(0,30) q = 2 n = 8 print(t) print(decimate(t,2)) print(resample(t, len(t)/2)) t2 = sin(t) print(t2) print(len(t2)) d2 = decimate(t2,2, ftype='fir') print(d2) print(len(d2)) b, a = cheby1(n, 0.05, 0.8 / q) print(b,a) y = filtfilt(b, a, t2) print(y) sl = [slice(None)] * y.ndim sl[-1] = slice(None, None, -q) print(sl) print(y[sl]) print(t2[sl]) #r2 = resample(t2, len(t2)/2) #print(r2) #print(len(r2)) assert(False)
def decimate_coeffs(q, n=None, ftype='iir'): if type(q) != type(1): raise Error, "q should be an integer" if n is None: if ftype == 'fir': n = 30 else: n = 8 if ftype == 'fir': coeffs = GlobalVars.decimate_fir_coeffs if (n, 1./q) not in coeffs: coeffs[n,1./q] = signal.firwin(n+1, 1./q, window='hamming') b = coeffs[n,1./q] return b, [1.], n else: coeffs = GlobalVars.decimate_iir_coeffs if (n,0.05,0.8/q) not in coeffs: coeffs[n,0.05,0.8/q] = signal.cheby1(n, 0.05, 0.8/q) b, a = coeffs[n,0.05,0.8/q] return b, a, n
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 decimate(x, q, n=None, ftype='iir', axis=-1, zero_phase=False): """ Downsample the signal by using a filter. By default, an order 8 Chebyshev type I filter is used. A 30 point FIR filter with hamming window is used if `ftype` is 'fir'. Parameters ---------- x : ndarray The signal to be downsampled, as an N-dimensional array. q : int The downsampling factor. n : int, optional The order of the filter (1 less than the length for 'fir'). ftype : str {'iir', 'fir'}, optional The type of the lowpass filter. axis : int, optional The axis along which to decimate. zero_phase : bool Prevent phase shift by filtering with ``filtfilt`` instead of ``lfilter``. Returns ------- y : ndarray The down-sampled signal. See also -------- resample Notes ----- The ``zero_phase`` keyword was added in 0.17.0. The possibility to use instances of ``lti`` as ``ftype`` was added in 0.17.0. """ if not isinstance(q, int): raise TypeError("q must be an integer") if ftype == 'fir': if n is None: n = 30 system = lti(firwin(n + 1, 1. / q, window='hamming'), 1.) elif ftype == 'iir': if n is None: n = 8 system = lti(*cheby1(n, 0.05, 0.8 / q)) else: system = ftype if zero_phase: y = filtfilt(system.num, system.den, x, axis=axis) else: y = lfilter(system.num, system.den, x, axis=axis) sl = [slice(None)] * y.ndim sl[axis] = slice(None, None, q) return y[sl]
def HPmin(self, fil_dict): self._get_params(fil_dict) self.N, self.F_PBC = cheb1ord(self.F_PB,self.F_SB, self.A_PB,self.A_SB, analog=self.analog) if not self._test_N(): return -1 self._save(fil_dict, sig.cheby1(self.N, self.A_PB, self.F_PBC, btype='highpass', analog=self.analog, output=self.FRMT))
def BSmin(self, fil_dict): self._get_params(fil_dict) self.N, self.F_PBC = cheb1ord([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.cheby1(self.N, self.A_PB, self.F_PBC, btype='bandstop', analog=self.analog, output=self.FRMT))
def cheby_filter(frames): b, a = signal.cheby1(order, rp, Wn, 'bandpass', analog=False) print "Filtering..." frames = signal.filtfilt(b, a, frames, axis=0) #for i in range(frames.shape[-1]): # frames[:, i] = signal.filtfilt(b, a, frames[:, i]) print "Done!" return frames
def __init__(self, threshold_freq, order=2, design='cheby1'): """ :param threshold_freq: Threshold frequency to filter out, as a fraction of sampling freq. E.g. 0.1 """ self.b, self.a = \ butter(N=order, Wn=threshold_freq, btype='low') if design == 'butter' else \ cheby1(N=order, rp=0.1, Wn=threshold_freq, btype='low') if design == 'cheby1' else \ bad_value(design) self.filter_state = lfilter_zi(b=self.b, a=self.a)
def decimate(x, q, n=None, ftype='iir', axis=-1): """Downsample the signal x by an integer factor q, using an order n filter By default, an order 8 Chebyshev type I filter is used or a 30 point FIR filter with hamming window if ftype is 'fir'. (port to python of the GNU Octave function decimate.) Inputs: x -- the signal to be downsampled (N-dimensional array) q -- the downsampling factor n -- order of the filter (1 less than the length of the filter for a 'fir' filter) ftype -- type of the filter; can be 'iir' or 'fir' axis -- the axis along which the filter should be applied Outputs: y -- the downsampled signal """ if type(q) != type(1): raise TypeError("q should be an integer") if n is None: if ftype == 'fir': n = 30 else: n = 8 if ftype == 'fir': # PBS - This method must be verified b = firwin(n+1, 1./q, window='hamming') y = lfilter(b, 1., x, axis=axis) else: (b, a) = cheby1(n, 0.05, 0.8/q) # reshape the data to 2D with time on the 2nd dimension origshape = x.shape y = reshape_to_2d(x,axis) # loop over final dimension for i in range(y.shape[0]): y[i] = filtfilt(b,a,y[i]) #y = filtfilt2(b,a,y) # reshape the data back y = reshape_from_2d(y,axis,origshape) # This needs to be filtfilt eventually #y = lfilter(b, a, x, axis=axis) return y.swapaxes(0,axis)[::q].swapaxes(0,axis)
def cheby1_lowpass_filter(_data, _frequency_cutoff, _carrier_frequency, order): """ :param _data: The data to be lowpassed :param _frequency_cutoff: The frequency cutoff for the filter :param _carrier_frequency: The carrier frequency for the filter :param order: The order of the filter :return: The output of the lowpass filter (entire window) """ nyq = 0.5 * _carrier_frequency low = _frequency_cutoff / nyq b, a = signal.cheby1(order, 5, low, 'low', analog=False, output='ba') return signal.lfilter(b, a, _data)
def decimate(x, q, n=None, ftype='iir', axis=-1): """ Downsample the signal by using a filter. By default, an order 8 Chebyshev type I filter is used. A 30 point FIR filter with hamming window is used if `ftype` is 'fir'. Parameters ---------- x : ndarray The signal to be downsampled, as an N-dimensional array. q : int The downsampling factor. n : int, optional The order of the filter (1 less than the length for 'fir'). ftype : str {'iir', 'fir'}, optional The type of the lowpass filter. axis : int, optional The axis along which to decimate. Returns ------- y : ndarray The down-sampled signal. See also -------- resample """ if not isinstance(q, int): raise TypeError("q must be an integer") if n is None: if ftype == 'fir': n = 30 else: n = 8 if ftype == 'fir': b = signal.firwin(n + 1, 1. / q, window='hamming') a = 1. else: b, a = signal.cheby1(n, 0.05, 0.8 / q) y = signal.lfilter(b, a, x, axis=axis) sl = [slice(None)] * y.ndim sl[axis] = slice(None, None, q) return y[sl]
def __init__(self,M_change = 12,fcutoff=0.9,N_filt_order=8,ftype='butter'): """ Object constructor method """ self.M = M_change # Rate change factor M or L self.fc = fcutoff*.5 # must be fs/(2*M), but scale by fcutoff self.N_forder = N_filt_order if ftype.lower() == 'butter': self.b, self.a = signal.butter(self.N_forder,2/self.M*self.fc) elif ftype.lower() == 'cheby1': # Set the ripple to 0.05 dB self.b, self.a = signal.cheby1(self.N_forder,0.05,2/self.M*self.fc) else: print('ftype must be "butter" or "cheby1"')
def decimate(q, target): b, a = signal.cheby1(4, 0.05, 0.8/q) if np.any(np.abs(np.roots(a)) > 1): raise ValueError, 'Unstable filter coefficients' zf = signal.lfilter_zi(b, a) y_remainder = np.array([]) while True: y = np.r_[y_remainder, (yield)] remainder = len(y) % q if remainder != 0: y, y_remainder = y[:-remainder], y[-remainder:] else: y_remainder = np.array([]) y, zf = signal.lfilter(b, a, y, zi=zf) target(y[::q])
def chebyshevplot(fs): """ https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.cheby1.html#scipy.signal.cheby1 """ b, a = signal.cheby1(4, 5, 100, 'high', analog=True) w, h = signal.freqs(b, a) ax = figure().gca() ax.semilogx(w, 20*np.log10(abs(h))) ax.set_title('Chebyshev Type I frequency response (rp=5)') ax.set_xlabel('Frequency [radians / second]') ax.set_ylabel('Amplitude [dB]') ax.grid(which='both', axis='both') ax.axvline(100, color='green') # cutoff frequency ax.axhline(-5, color='green') # rp
def cheby1_highpass_test(): import numpy as np from numpy.testing import assert_almost_equal from scipy.signal import cheby1 x = np.arange(10000).reshape(1, -1) d = np.sin(x * 2 * np.pi * 1000 / 48000) out, b, a = filter_high(d) bref, aref = cheby1(5, 3, 1000/24000., btype='highpass') assert_almost_equal(-b, bref) assert_almost_equal(np.hstack(([1], -a[::-1])), aref)
def blackbox(x, samplerate, axis=0): """Some unknown (except that it's LTI) digital system. Parameters ---------- x : array_like Input signal. samplerate : float Sampling rate in Hertz. axis : int, optional The axis of the input data array along which to apply the system. By default, this is the first axis. Returns ------- numpy.ndarray The output signal. """ # You are not supposed to look! b, a = signal.cheby1(8, 0.1, 3400 * 2 / samplerate) x = signal.lfilter(b, a, x, axis) b, a = signal.cheby1(4, 0.1, 300 * 2 / samplerate, 'high') return signal.lfilter(b, a, x, axis)
def cheby_filter(frames, low_limit, high_limit): nyq = frame_rate/2.0 low_limit = low_limit/nyq high_limit = high_limit/nyq order = 4 rp = 0.1 Wn = [low_limit, high_limit] b, a = signal.cheby1(order, rp, Wn, 'bandpass', analog=False) print "Filtering..." frames = signal.filtfilt(b, a, frames, axis=0) #frames = parmap.map(filt, frames.T, b, a) #for i in range(frames.shape[-1]): # frames[:, i] = signal.filtfilt(b, a, frames[:, i]) print "Done!" return frames
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 iir_basic(a): filt_type = a["Response Type"] print('filt_type', filt_type) design_method = a["Design_Methode"] if design_method == 'Elliptic': ftype = 'ellip' elif design_method == 'Chebychev 1': ftype = 'cheby1' elif design_method == 'Chebychev 2': ftype = 'cheby2' elif design_method == 'Butterworth': ftype = 'butter' # else: raise_exception print('design_method', design_method) N = a['Order'] print('order',N) fs = a["Fs"] F_pass = 2 * a["Fpass"]/fs # F_stop = 2 * a[3][2][2]/fs F_stop = 0.8 print('fs','fpass','fstop',fs, F_pass, F_stop) A_pass = a["Apass"] A_stop = a["Astop"] # A_stop = a[4][2][2] print('A_pass', 'A_stop', A_pass, A_stop) # W = a[5] # print('W',W) if N == 'min': b,a = sig.iirdesign(F_pass, F_stop, A_pass, A_stop, analog = False, ftype = ftype, output = 'ba') else: if ftype == 'ellip': b,a = sig.ellip(N, A_pass, A_stop, [F_pass, F_stop], btype ='low' ) elif ftype == 'cheby1': b,a = sig.cheby1(N, A_pass, [F_pass, F_stop], btype ='low' ) elif ftype == 'cheby2': b,a = sig.cheby2(N, A_stop, [F_pass, F_stop], btype ='low' ) elif ftype == 'butter': b,a = sig.butter(N, (2 * a["Fc"]/fs), btype ='low' ) return b, a
def cheby_filter(self, frames, low_limit, high_limit, frame_rate): nyq = frame_rate / 2.0 low_limit = low_limit / nyq high_limit = high_limit / nyq order = 4 rp = 0.1 # Ripple in the passband. Maximum allowable ripple Wn = [low_limit, high_limit] b, a = signal.cheby1(order, rp, Wn, 'bandpass', analog=False) print("Filtering...") frames = signal.filtfilt(b, a, frames, axis=0) # non-working parallized version # def filt(pixel, b, a): # return signal.filtfilt(b, a, pixel) # frames = parmap.map(filt, frames.T, b, a) # for i in range(frames.shape[-1]): # frames[:, i] = 'signal.filtfilt(b, a, frames[:, i]) print("Done!") return frames
def design(self, ripple=None): if self.filter_class == 'butterworth': self.B, self.A = signal.butter(self.N, self.Wn, self.filter_type, analog=True, output='ba') elif self.filter_class == 'chebyshev_1': if ripple is None or ripple <= 0: raise ValueError("Must give a ripple that is > 0") self.B, self.A = signal.cheby1(self.N, ripple, self.Wn, self.filter_type, analog=True, output='ba') elif self.filter_class == 'chebyshev_2': self.B, self.A = signal.cheby2(self.N, self.stopband_attenuation, self.Wn, self.filter_type, analog=True, output='ba') elif self.filter_class == 'elliptical': self.B, self.A = signal.ellip(self.N, self.passband_attenuation, self.stopband_attenuation, self.Wn, self.filter_type, analog=True, output='ba') elif self.filter_class == 'bessel': self.B, self.A = signal.bessel(self.N, self.Wn, self.filter_type, analog=True) else: raise NotImplementedError("Computation of {} not implemented yet.".format(self.filter_class))
def decimate(x, q, n=None, ftype='iir', axis=-1): """downsample the signal x by an integer factor q, using an order n filter By default, an order 8 Chebyshev type I filter is used or a 30 point FIR filter with hamming window if ftype is 'fir'. (port to python of the GNU Octave function decimate.) Inputs: x -- the signal to be downsampled (N-dimensional array) q -- the downsampling factor n -- order of the filter (1 less than the length of the filter for a 'fir' filter) ftype -- type of the filter; can be 'iir' or 'fir' axis -- the axis along which the filter should be applied Outputs: y -- the downsampled signal """ if type(q) != type(1): raise Error, "q should be an integer" if n is None: if ftype == 'fir': n = 30 else: n = 4 if ftype == 'fir': b = firwin(n+1, 1./q, window='hamming') y = lfilter(b, 1., x, axis=axis) else: (b, a) = cheby1(n, 0.05, 0.8/q) y = lfilter(b, a, x, axis=axis) return y.swapaxes(0,axis)[::q].swapaxes(0,axis)
def TPI(dataset,n,rp,wn): """ A function to apply a 13 year Chebyshev low pass filter to the unfiltered TPI output, from TPIunfil(). The filter design is a digital, type 1 (passband) Chebyshev filter. The filter itself is a zero-phase filter, as a forward-in-time only filter shifts the signal as it filters (resulting in a delayed signal). Parameters: ----------- dataset : the data to filter. Will either be: Had_monthsTPI_uf or Acc_monthsTPI_uf (see 'tpi_csv.py'). n = filter order (Henley et al.: n = 6). rp = peak to peak passband ripple. In decibels; positive number. (Henley et al.: rp = 13). wn = critical frequencies. Between 0-1, where 1 is the Nyquist frequency, pi radians/sample. (Henley et al.: wn = 0.1). """ b, a = signal.cheby1(n, rp, wn, btype='low', analog=False, output='ba') TPI = signal.filtfilt(b,a,dataset) return TPI
def TPI(dataset, n, rp, wn): """ A function to apply a 13 year Chebyshev low pass filter to the unfiltered TPI output, from TPIunfil(). The filter design is a digital, type 1 (passband) Chebyshev filter. The filter itself is a zero-phase filter, as a forward-in-time only filter shifts the signal as it filters (resulting in a delayed signal). Parameters: ----------- dataset : the data to filter. Will either be: Had_monthsTPI_uf or Acc_monthsTPI_uf (see 'tpi_csv.py'). n = filter order (Henley et al.: n = 6). rp = peak to peak passband ripple. In decibels; positive number. (Henley et al.: rp = 13). wn = critical frequencies. Between 0-1, where 1 is the Nyquist frequency, pi radians/sample. (Henley et al.: wn = 0.1). """ b, a = signal.cheby1(n, rp, wn, btype='low', analog=False, output='ba') TPI = signal.filtfilt(b, a, dataset) return TPI
def cheby1_bandpass(low, high, fs, order): nyq = 0.5 * fs n_low = low / nyq n_high = high / nyq b, a = cheby1(order,0.2, [n_low, n_high], btype='band', analog=False) fig2 = plt.figure() plt.title('Digital filter frequency response') ax1 = fig2.add_subplot(211) w, h = signal.freqz(b,a) plt.plot(w/(math.pi*2)*fs, abs(h), 'b') plt.ylabel('Amplitude', color='b') plt.xlabel('Frequency [freq/sample]') ax2 = ax1.twinx() angles = np.unwrap(np.angle(h)) plt.plot(w/(math.pi*2)*fs, angles, 'g') plt.ylabel('Angle (radians)', color='g') plt.grid() plt.axis('tight') plt.show() return b, a
def __init__( self, low_freq_cutoff, high_freq_cutoff, frame_rate, order=4, rp=0.1, ): """ Create Bandpass Filter object with frequency cutoff attributes :param low_freq_cutoff: first critical frequency :type: float>0 :param high_freq_cutoff: second critical frequency :type: float>0 :param frame_rate: frame rate of the footage :type: float>0 :param order: the order of the filter :type: int :param rp: maximum ripple allowed below unity gain in the passband. Specified in decibels, as a positive number :type: float>0 """ nyq = frame_rate * 0.5 passband = low_freq_cutoff / nyq stopband = high_freq_cutoff / nyq numerator, denominator = signal.cheby1( order, rp, Wn=[passband, stopband], btype="bandpass", analog=False, ) self.numerator, self.denominator = ( numerator, denominator, )
def make_filter( dataset: list, bandwidth: list, fs: int, order: int, rp: int) -> list: """ Apply Chebyshev bandpass filter to dataset with bandwidth. input: dataset - data of EEG signal for filtering; bandwidth - list of borders frequencies for filtering in Hz; fs - frequency sample rate; order - order of Chebyshev filter; rp - The maximum ripple allowed below unity gain in the passband; Returns: list of filtered data of EEG signal. """ # prepare data of signal data = np.array(dataset) # convert border frequencies from Hz # to sampling frequency of the digital system nyq = 0.5 * fs normal_bandpass = [bandwidth[0] / nyq, bandwidth[1] / nyq] # applying Butterworth filter # b, a = butter( b, a = cheby1( N=order, rp=rp, Wn=normal_bandpass, btype='bandpass', analog=False) # b, a - Numerator (b) and denominator # (a) polynomials of the IIR filter return filtfilt(b, a, data) # lfilter(b, a, data)
def decimate(x, q, n=None, ftype='iir', axis=-1): """downsample the signal x by an integer factor q, using an order n filter By default, an order 8 Chebyshev type I filter is used or a 30 point FIR filter with hamming window if ftype is 'fir'. (port to python of the GNU Octave function decimate.) Inputs: x -- the signal to be downsampled (N-dimensional array) q -- the downsampling factor n -- order of the filter (1 less than the length of the filter for a 'fir' filter) ftype -- type of the filter; can be 'iir' or 'fir' axis -- the axis along which the filter should be applied Outputs: y -- the downsampled signal """ if type(q) != type(1): raise Error, "q should be an integer" if n is None: if ftype == 'fir': n = 30 else: n = 8 if ftype == 'fir': b = signal.firwin(n + 1, 1. / q, window='hamming') y = signal.lfilter(b, 1., x, axis=axis) else: (b, a) = signal.cheby1(n, 0.05, 0.8 / q) y = signal.lfilter(b, a, x, axis=axis) return y.swapaxes(0, axis)[n / 2::q].swapaxes(0, axis)
def decimate(s, r, n=None, fir=False): """Decimation - decrease sampling rate by r. The decimation process filters the input data s with an order n lowpass filter and then resamples the resulting smoothed signal at a lower rate. By default, decimate employs an eighth-order lowpass Chebyshev Type I filter with a cutoff frequency of 0.8/r. It filters the input sequence in both the forward and reverse directions to remove all phase distortion, effectively doubling the filter order. If 'fir' is set to True decimate uses an order 30 FIR filter (by default otherwise n), instead of the Chebyshev IIR filter. Here decimate filters the input sequence in only one direction. This technique conserves memory and is useful for working with long sequences. """ if fir: if n is None: n = 30 b = signal.firwin(n, 1.0/r) a = 1 f = signal.lfilter(b, a, s) else: #iir if n is None: n = 8 b, a = signal.cheby1(n, 0.05, 0.8/r) f = signal.filtfilt(b, a, s) return downsample(f, r)
def __init__(self,channels=8,yamp = 100,timerange=5,srate = 250, notchfilter=True,bandpass = [1,90]): self.channels = channels self.yamp = yamp self.timerange = timerange self.srate = srate self.notchfilter = notchfilter self.bandpass = [1,90] fs = self.srate/2 if self.bandpass is not None: self._bp = True # bandpass filter Wp = np.array([bandpass[0] / fs, bandpass[1] / fs]) Ws = np.array([(bandpass[0]*0.5) / fs, (bandpass[1]+10) / fs]) N, Wn = scipy_signal.cheb1ord(Wp, Ws, 3, 40) self.bpB, self.bpA = scipy_signal.cheby1(N, 0.5, Wn, 'bandpass') else: self._bp = False # notch filter Fo = 50 Q = 15 w0 = Fo / (fs) self.notchB, self.notchA = scipy_signal.iirnotch(w0=w0, Q=Q) self._plength = self.srate * timerange self._flength = self.srate * (1+timerange) self._t = np.arange(0,timerange,1/self.srate) self.signal = [np.ones([self.channels,self._t.size])] self.update_yscale() self.ticks = [] for i in range(self.channels): self.ticks.append('ch'+str(i+1)) plt.ion()
def createCoeffs(order, cutoff, filterType, design='butter', rp=1, rs=1, fs=0): #defining the acceptable inputs for the design and filterType params designs = ['butter', 'cheby1', 'cheby2'] filterTypes1 = [ 'lowpass', 'highpass', 'Lowpass', 'Highpass', 'low', 'high' ] filterTypes2 = ['bandstop', 'bandpass', 'Bandstop', 'Bandpass'] #Error handling: other errors can arise too, but those are dealt with #in the signal package. isThereAnError = 1 #if there was no error then it will be set to 0 COEFFS = [0] #with no error this will hold the coefficients if design not in designs: print('Gave wrong filter design! Remember: butter, cheby1, cheby2.') elif filterType not in filterTypes1 and filterType not in filterTypes2: print('Gave wrong filter type! Remember: lowpass, highpass', ', bandpass, bandstop.') elif fs < 0: print('The sampling frequency has to be positive!') else: isThereAnError = 0 #if fs was given then the given cutoffs need to be normalised to Nyquist if fs and isThereAnError == 0: for i in range(len(cutoff)): cutoff[i] = cutoff[i] / fs * 2 if design == 'butter' and isThereAnError == 0: COEFFS = signal.butter(order, cutoff, filterType, output='sos') elif design == 'cheby1' and isThereAnError == 0: COEFFS = signal.cheby1(order, rp, cutoff, filterType, output='sos') elif design == 'cheby2' and isThereAnError == 0: COEFFS = signal.cheby2(order, rs, cutoff, filterType, output='sos') return COEFFS
def _filterbank(self, eeg, idx_fbi): ''' ''' if eeg.ndim == 2: num_chans = eeg.shape[0] num_trials = 1 else: num_chans, _, num_trials = eeg.shape fs = self.fs / 2 passband = [6, 14, 22, 30, 38, 46, 54, 62, 70, 78] stopband = [4, 10, 16, 24, 32, 40, 48, 56, 64, 72] Wp = [passband[idx_fbi]/fs, 90/fs] Ws = [stopband[idx_fbi]/fs, 100/fs] [N, Wn] = cheb1ord(Wp, Ws, 3, 40) [B, A] = cheby1(N, 0.5, Wn, 'bp') yy = np.zeros_like(eeg) if num_trials == 1: yy = filtfilt(B, A, eeg, axis=1) else: for trial_i in range(num_trials): for ch_i in range(num_chans): # yy[ch_i, :, trial_i] = filtfilt(B, A, eeg[ch_i, :, trial_i]) yy[ch_i, :, trial_i] = filtfilt(B, A, eeg[ch_i, :, trial_i], padtype='odd', padlen=3*(max(len(B),len(A))-1)) return yy
def bandpass(eeg, sfreq, Wp, Ws): """Filter bank design for decomposing EEG data into sub-band components. Parameters ---------- eeg : np.array, shape=(n_samples, n_chans[, n_trials]) Training data. sfreq : int Sampling frequency of the data. Wp : 2-tuple Passband for Chebyshev filter. Ws : 2-tuple Stopband for Chebyshev filter. Returns ------- y: np.array, shape=(n_trials, n_chans, n_samples) Sub-band components decomposed by a filter bank. See Also -------- scipy.signal.cheb1ord : Chebyshev type I filter order selection. """ # Chebyshev type I filter order selection. N, Wn = cheb1ord(Wp, Ws, 3, 40, fs=sfreq) # Chebyshev type I filter design B, A = cheby1(N, 0.5, Wn, btype="bandpass", fs=sfreq) # the arguments 'axis=0, padtype='odd', padlen=3*(max(len(B),len(A))-1)' # correspond to Matlab filtfilt : https://dsp.stackexchange.com/a/47945 y = filtfilt(B, A, eeg, axis=0, padtype='odd', padlen=3 * (max(len(B), len(A)) - 1)) return y
def decimate(s, r, n=None, fir=False): """Decimation - decrease sampling rate by r. The decimation process filters the input data s with an order n lowpass filter and then resamples the resulting smoothed signal at a lower rate. By default, decimate employs an eighth-order lowpass Chebyshev Type I filter with a cutoff frequency of 0.8/r. It filters the input sequence in both the forward and reverse directions to remove all phase distortion, effectively doubling the filter order. If 'fir' is set to True decimate uses an order 30 FIR filter (by default otherwise n), instead of the Chebyshev IIR filter. Here decimate filters the input sequence in only one direction. This technique conserves memory and is useful for working with long sequences. """ if fir: if n is None: n = 30 b = signal.firwin(n, 1.0 / r) a = 1 f = signal.lfilter(b, a, s) else: #iir if n is None: n = 8 b, a = signal.cheby1(n, 0.05, 0.8 / r) f = signal.filtfilt(b, a, s) return downsample(f, r)
fs = 3 # 阻止域端周波数[Hz] gpass = 1 # 通過域最大損失量[dB] gstop = 40 # 阻止域最小減衰量[dB] # 正規化 Wp = fp / fn Ws = fs / fn # ローパスフィルタで波形整形 # バターワースフィルタ N, Wn = signal.buttord(Wp, Ws, gpass, gstop) b1, a1 = signal.butter(N, Wn, "low") y1 = signal.filtfilt(b1, a1, y) # 第一種チェビシェフフィルタ N, Wn = signal.cheb1ord(Wp, Ws, gpass, gstop) b2, a2 = signal.cheby1(N, gpass, Wn, "low") y2 = signal.filtfilt(b2, a2, y) # 第二種チェビシェフフィルタ N, Wn = signal.cheb2ord(Wp, Ws, gpass, gstop) b3, a3 = signal.cheby2(N, gstop, Wn, "low") y3 = signal.filtfilt(b3, a3, y) # 楕円フィルタ N, Wn = signal.ellipord(Wp, Ws, gpass, gstop) b4, a4 = signal.ellip(N, gpass, gstop, Wn, "low") y4 = signal.filtfilt(b4, a4, y) # ベッセルフィルタ N = 4 b5, a5 = signal.bessel(N, Ws, "low")
def initial_preprocessing(self, bp_lowcut=1, bp_highcut=70, bp_order=2, notch_freq_Hz=[60.0, 120.0], notch_order=2): """ Filters the data by applying - An SL filter - A zero-phase Butterworth bandpass was applied from 1 – 70 Hz. - A 60-120 Hz notch filter to suppress line noise Input: - bp_ lowcut: lower cutoff frequency for bandpass filter - bp_highcut: higher cutoff frequency for bandpass filter - bp_order: order of bandpass filter - notch_freq_Hz: cutoff frequencies for notch fitltering - notch_order: order of notch filter """ self.nyq = 0.5 * self.sample_rate #Nyquist frequency self.low = bp_lowcut / self.nyq self.high = bp_highcut / self.nyq # SL filter self.sl_filtered_data = self.raw_eeg_data raw_channels = self.raw_eeg_data.transpose() sl_channels = deepcopy(raw_channels) # Subtract average of adjacent electrodes sl_channels[0] -= (raw_channels[1] + raw_channels[2] + raw_channels[4]) / 3 # C1 -= (C2 + C3 + Cp1) / 3 sl_channels[1] -= (raw_channels[0] + raw_channels[3] + raw_channels[5]) / 3 # C2 -= (C1 + C4 + Cp2) / 3 sl_channels[2] -= (raw_channels[0] + raw_channels[6]) / 3 # C3 -= (C1 + Cp3) / 2 sl_channels[3] -= (raw_channels[1] + raw_channels[7]) / 3 # C4 -= (C2 + Cp4) / 2 sl_channels[4] -= (raw_channels[5] + raw_channels[6] + raw_channels[0]) / 3 # Cp1 -= (Cp2 + Cp3 + C1) / 3 sl_channels[5] -= (raw_channels[4] + raw_channels[7] + raw_channels[1]) / 3 # Cp2 -= (Cp1 + Cp4 + C2) / 3 sl_channels[6] -= (raw_channels[4] + raw_channels[2]) / 3 # Cp3 -= (Cp1 + C3) / 2 sl_channels[7] -= (raw_channels[5] + raw_channels[3]) / 3 # Cp4 -= (Cp2 + C4) / 2 self.sl_filtered_data = sl_channels.transpose() #Bandpass filter plt.figure(figsize=(16, 12)) # bunch of different filters plt.subplot(221) b_bandpass, a_bandpass = butter(bp_order, [bp_lowcut, bp_highcut], btype='band', analog=True) w, h = freqs(b_bandpass, a_bandpass) #plt.plot(w, 20 * np.log10(abs(h))) plt.semilogx(w, 20 * np.log10(abs(h))) plt.xscale('log') plt.xlim([0.1, 1000]) plt.title('Butterworth filter frequency response ') plt.xlabel('Frequency [radians / second]') plt.ylabel('Amplitude [dB]') plt.margins(0, 0.1) plt.grid(which='both', axis='both') plt.subplot(222) b, a = ellip(bp_order, 5, 40, [bp_lowcut, bp_highcut], 'bandpass', analog=True) w, h = freqs(b, a) plt.semilogx(w, 20 * np.log10(abs(h))) plt.xlim([0.1, 1000]) plt.title('Elliptic filter frequency response (rp=5, rs=40)') plt.xlabel('Frequency [radians / second]') plt.ylabel('Amplitude [dB]') plt.margins(0, 0.1) plt.grid(which='both', axis='both') plt.subplot(223) b, a = cheby1(bp_order, 5, [bp_lowcut, bp_highcut], 'bandpass', analog=True) w, h = freqs(b, a) plt.plot(w, 20 * np.log10(abs(h))) plt.xlim([0.1, 1000]) plt.xscale('log') plt.title('Chebyshev Type I frequency response (rp=5)') plt.ylabel('Amplitude [dB]') plt.margins(0, 0.1) plt.grid(which='both', axis='both') plt.subplot(224) b, a = cheby2(bp_order, 5, [bp_lowcut, bp_highcut], 'bandpass', analog=True) w, h = freqs(b, a) plt.plot(w, 20 * np.log10(abs(h))) plt.xlim([0.1, 1000]) plt.xscale('log') plt.title('Chebyshev Type II frequency response (rp=5)') plt.ylabel('Amplitude [dB]') plt.margins(0, 0.1) plt.grid(which='both', axis='both') # filter designed using the windowing method (firwin). this filter with specified parameters seem to have decent passband, good supression of 60/120 hz artifacts and would be useful online due to relitavely short memory (in this case 2^6-1 = 63) # can vue time domain of filter plt.plot(b). x-axis is sample b = firwin(2**6 - 1, [0.5, 30], width=0.05, pass_zero=False, fs=sampling_freq) # length = order + 1 plt.figure() b_fft = np.fft.rfft(b) f = np.linspace(0, 125, len(b_fft)) plt.plot(f, abs(b_fft)) b_bandpass, a_bandpass = butter(bp_order, [self.low, self.high], btype='band', analog=True) # plt.figure() # plt.plot(b_bandpass,a_bandpass) self.bp_filtered_eeg_data = np.apply_along_axis( lambda l: lfilter(b_bandpass, a_bandpass, l), 0, self.sl_filtered_data) self.notch_filtered_eeg_data = self.bp_filtered_eeg_data for freq_Hz in notch_freq_Hz: bp_stop_Hz = freq_Hz + float(notch_order) * np.array( [-1, 1]) # set the stop band b_notch, a_notch = butter(notch_order, bp_stop_Hz / self.nyq, 'bandstop') self.notch_filtered_eeg_data = np.apply_along_axis( lambda l: lfilter(b_notch, a_notch, l), 0, self.notch_filtered_eeg_data)
for index in range(sos.shape[0]): ba = sos[index] filter_tmp = IIR2Filter(ba[0], ba[1], ba[2], ba[3], ba[4], ba[5]) self.sos_filters.append(filter_tmp) def filter(self, x): #x as input acc_input=accumulator input output = x for filter in self.sos_filters: output = filter.filter(output) return output if (__name__ == "__main__"): fs = 1000 T = 1 / fs n = 1000 x = np.linspace(0, (n - 1) * T, n) y = 3 * np.cos(2 * np.pi * 80 * x) + np.cos(2 * np.pi * 200 * x) + np.cos( 2 * np.pi * 300 * x) sos = signal.cheby1(8, 1, 100 / fs * 2, output='sos') result = np.array([]) filter = IIRFilter(sos) for yi in y: result = np.append(result, filter.filter(yi)) plt.plot(y, label="raw data") plt.plot(result, label="filtered") plt.legend() plt.show()
def cheby_design(cutoff, fs, type, order): return cheby1(N=order, rp=2.5, Wn=cutoff / (0.5 * fs), btype=type, analog=False)
def test_cheby1_5(self): # Test case for bandpass filter without default IIR = IIRDesign.cheby1(self.n, self.Rp, self.Wp2, ftype='bandpass') iir = signal.cheby1(self.n, self.Rp, self.Wp2, btype='bandpass', fs=2) self.assertTrue((IIR[0] == iir[0]).all() and (IIR[1] == iir[1]).all())
def __init__(self, ninputs, enc_fmaps, kwidth, activations, lnorm=False, dropout=0., pooling=2, z_dim=256, z_all=False, skip=True, skip_blacklist=[], dec_activations=None, cuda=False, bias=False, aal=False, wd=0., skip_init='one', skip_dropout=0., no_tanh=False, aal_out=False, rnn_core=False, linterp=False, mlpconv=False, dec_kwidth=None, no_z=False, skip_type='alpha', num_spks=None, multilayer_out=False, skip_merge='sum', snorm=False, convblock=False, post_skip=False, pos_code=False, satt=False, dec_fmaps=None, up_poolings=None, post_proc=False, out_gate=False, linterp_mode='linear', hidden_comb=False, big_out_filter=False, z_std=1, freeze_enc=False, skip_kwidth=11, pad_type='constant'): # if num_spks is specified, do onehot coditioners in dec stages # subract_mean: from output signal, get rif of mean by windows # multilayer_out: add some convs in between gblocks in decoder super().__init__(name='Generator1D') self.dec_kwidth = dec_kwidth self.skip_kwidth = skip_kwidth self.skip = skip self.skip_init = skip_init self.skip_dropout = skip_dropout self.snorm = snorm self.z_dim = z_dim self.z_all = z_all self.pos_code = pos_code self.post_skip = post_skip self.big_out_filter = big_out_filter self.satt = satt self.post_proc = post_proc self.pad_type = pad_type self.onehot = num_spks is not None if self.onehot: assert num_spks > 0 self.num_spks = num_spks # do not place any z self.no_z = no_z self.do_cuda = cuda self.wd = wd self.no_tanh = no_tanh self.skip_blacklist = skip_blacklist self.z_std = z_std self.freeze_enc = freeze_enc self.gen_enc = nn.ModuleList() if aal or aal_out: # Make cheby1 filter to include into pytorch conv blocks from scipy.signal import cheby1, dlti, dimpulse system = dlti(*cheby1(8, 0.05, 0.8 / pooling)) tout, yout = dimpulse(system) filter_h = yout[0] if aal: self.filter_h = filter_h else: self.filter_h = None if dec_kwidth is None: dec_kwidth = kwidth if isinstance(activations, str): if activations != 'glu': activations = getattr(nn, activations)() if not isinstance(activations, list): activations = [activations] * len(enc_fmaps) if not isinstance(pooling, list) or len(pooling) == 1: pooling = [pooling] * len(enc_fmaps) skips = {} # Build Encoder for layer_idx, (fmaps, pool, act) in enumerate(zip(enc_fmaps, pooling, activations)): if layer_idx == 0: inp = ninputs else: inp = enc_fmaps[layer_idx - 1] if self.skip and layer_idx < (len(enc_fmaps) - 1): if layer_idx not in self.skip_blacklist: l_i = layer_idx gskip = GSkip(skip_type, fmaps, skip_init, skip_dropout, merge_mode=skip_merge, cuda=self.do_cuda, kwidth=self.skip_kwidth) skips[l_i] = {'alpha': gskip} setattr(self, 'alpha_{}'.format(l_i), skips[l_i]['alpha']) self.gen_enc.append( GBlock(inp, fmaps, kwidth, act, padding=None, lnorm=lnorm, dropout=dropout, pooling=pool, enc=True, bias=bias, aal_h=self.filter_h, snorm=snorm, convblock=convblock, satt=self.satt, pad_type=pad_type)) self.skips = skips dec_inp = enc_fmaps[-1] if dec_fmaps is None: if mlpconv: dec_fmaps = enc_fmaps[:-1][::-1] + [16, 8, 1] print(dec_fmaps) up_poolings = [pooling] * (len(dec_fmaps) - 2) + [1] * 3 add_activations = [nn.PReLU(16), nn.PReLU(8), nn.PReLU(1)] raise NotImplementedError('MLPconv is not useful and should be' ' deleted') else: dec_fmaps = enc_fmaps[:-1][::-1] + [1] up_poolings = pooling[::-1] #up_poolings = [pooling] * len(dec_fmaps) print('up_poolings: ', up_poolings) self.up_poolings = up_poolings else: assert up_poolings is not None self.up_poolings = up_poolings if rnn_core: self.z_all = False z_all = False # place a bidirectional RNN layer in the core to condition # everything to everything AND Z will be the init state of it self.rnn_core = nn.LSTM(dec_inp, dec_inp // 2, bidirectional=True, batch_first=True) else: if no_z: all_z = False else: dec_inp += z_dim #print(dec_fmaps) # Build Decoder self.gen_dec = nn.ModuleList() if dec_activations is None: # assign same activations as in Encoder dec_activations = [activations[0]] * len(dec_fmaps) else: if mlpconv: dec_activations = dec_activations[:-1] dec_activations += add_activations enc_layer_idx = len(enc_fmaps) - 1 for layer_idx, (fmaps, act) in enumerate(zip(dec_fmaps, dec_activations)): if skip and layer_idx > 0 and enc_layer_idx not in skip_blacklist \ and up_poolings[layer_idx] > 1: if skip_merge == 'concat': dec_inp *= 2 print('Added skip conn input of enc idx: {} and size:' ' {}'.format(enc_layer_idx, dec_inp)) if z_all and layer_idx > 0: dec_inp += z_dim if self.onehot: dec_inp += self.num_spks if layer_idx >= len(dec_fmaps) - 1: if self.no_tanh: act = None else: act = nn.Tanh() lnorm = False dropout = 0 if up_poolings[layer_idx] > 1: pooling = up_poolings[layer_idx] self.gen_dec.append( GBlock(dec_inp, fmaps, dec_kwidth, act, padding=0, lnorm=lnorm, dropout=dropout, pooling=pooling, enc=False, bias=bias, linterp=linterp, linterp_mode=linterp_mode, convblock=convblock, comb=hidden_comb, pad_type=pad_type)) else: self.gen_dec.append( GBlock( dec_inp, fmaps, dec_kwidth, act, lnorm=lnorm, dropout=dropout, pooling=1, padding=0, #kwidth//2, enc=True, bias=bias, convblock=convblock, pad_type=pad_type)) dec_inp = fmaps if aal_out: # make AAL filter to put in output self.aal_out = nn.Conv1d(1, 1, filter_h.shape[0] + 1, stride=1, padding=filter_h.shape[0] // 2, bias=False) print('filter_h shape: ', filter_h.shape) # apply AAL weights, reshaping impulse response to match # in channels and out channels aal_t = torch.FloatTensor(filter_h).view(1, 1, -1) aal_t = torch.cat((aal_t, torch.zeros(1, 1, 1)), dim=-1) self.aal_out.weight.data = aal_t print('aal_t size: ', aal_t.size()) if post_proc: self.comb_net = PostProcessingCombNet(1, 512) if out_gate: self.out_gate = OutGate(1, 1) if big_out_filter: self.out_filter = nn.Conv1d(1, 1, 513, padding=513 // 2)
def test_cheby1_6(self): # Test case for bandstop filter IIR = IIRDesign.cheby1(self.n, self.Rp, self.Wp2, ftype='stop') iir = signal.cheby1(self.n, self.Rp, self.Wp2, btype='bandstop', fs=2) self.assertTrue((IIR[0] == iir[0]).all() and (IIR[1] == iir[1]).all())
def cheby_lowpass(cutoff, fs, order, rp): nyq = 0.5 * fs normal_cutoff = cutoff / nyq b, a = cheby1(order, rp, normal_cutoff, btype='low', analog=False) return b, a
plt.ylim([-60, 12]) plt.ylabel('Amplitude [dB]') plt.grid(which='both', axis='both') plt.axvline(omega_c * np.pi, color='black') # cutoff frequency plt.legend() plt.savefig('Butterworth.png') # ---------- chebyshev 1 ---------- bArray = [] aArray = [] wArray = [] hArray = [] orderArray = [1, 2, 4, 5] omega_c = 0.25 for i in orderArray: b, a = signal.cheby1(N=i, rp=6, Wn=omega_c) if i == 4: filterSystems.append([b, a]) w, h = signal.freqz(b, a) bArray.append(b) aArray.append(a) wArray.append(w) hArray.append(h) fig = plt.figure(figsize=(16, 9)) for index in range(len(orderArray)): plt.plot(wArray[index], 20 * np.log10(abs(hArray[index])), label="order = " + str(orderArray[index])) plt.title('Chebyshev Type 1 Filter Frequency Response: Comparison') plt.xlabel('Frequency [up to Nyquist]')
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Sat Apr 13 12:14:28 2019 @author: ivanpauno """ import scipy.signal as sig import matplotlib.pyplot as plt import filter_utils # Comparación orden 3, att max 3dB num, den = sig.butter(3, 1, analog=True) # n, wp butter = sig.TransferFunction(num, den) num, den = sig.cheby1(3, 3, 1, analog=True) # n, att max, wp cheby1 = sig.TransferFunction(num, den) num, den = sig.cheby2(3, 20, 1.539389818149637, analog=True) # n, att min, ws cheby2 = sig.TransferFunction(num, den) num, den = sig.bessel(3, 1, analog=True, norm='mag') # n, wp bessel = sig.TransferFunction(num, den) num, den = sig.ellip(3, 3, 20, 1, analog=True) # n, att max, att min, wp ellip = sig.TransferFunction(num, den) print('Transferencia Butterworth:\n') filter_utils.pretty(butter.num, butter.den) print('\n\n') filter_utils.print_zpk(butter.num, butter.den) print('\n\nTransferencia Chebyshev tipo 1:\n') filter_utils.pretty(cheby1.num, cheby1.den) print('\n\n')
def custom_cheby1(data, Fs, N, Rp, Wp, Ws=None, filtresponse='bandpass', analog_value=False, showresponse=0): nyquist = Fs / 2 if filtresponse == 'bandpass': Wn = [Wp / nyquist, Ws / nyquist] else: Wn = [Wp / nyquist] b, a = signal.cheby1(N, Rp, Wn, 'bandpass', analog=analog_value) if data != []: if len(data.shape) > 1: #print('Filtering multidimensional array!') filtered_data = np.zeros((data.shape[0], data.shape[1])) filtered_data = signal.filtfilt(b, a, data, axis=1) #for channel_num in range(0, data.shape[0]): # # filtered_data[channel_num,:] = signal.lfilter(b, a, data[channel_num,:]) # filtered_data[channel_num, :] = signal.filtfilt(b, a, data[channel_num, :]) else: # filtered_data = signal.lfilter(b, a, data) filtered_data = signal.filtfilt(b, a, data) if showresponse == 1: if showresponse == 1: # set to 1 if you want to visualize the frequency response of the filter FType = 'Chebyshev I' mode = 'Digital' w, h = signal.freqz( b, a, worN=8000 ) # returns the requency response h, and the normalized angular # frequencies w in radians/sample # w (radians/sample) * Fs (samples/sec) * (1 cycle/2pi*radians) = Hz f = Fs * w / (2 * np.pi) # Hz plt.figure(figsize=(10, 5)) # plt.subplot(211) plt.semilogx(f, np.abs(h), 'b') plt.xscale('log') if Ws is not None: plt.title( '%s Bandpass Filter Frequency Response (Order = %s, Wp=%s (Hz), Ws =%s (Hz))' % (FType, N, Wp, Ws)) else: plt.title( '%s Lowpass Filter Frequency Response (Order = %s, Wp=%s (Hz))' % (FType, N, Wp)) plt.xlabel('Frequency(Hz)') plt.ylabel('Gain [V/V]') plt.margins(0, 0.1) plt.grid(which='both', axis='both') plt.axvline(Wp, color='green') if Ws is not None: plt.axvline(Ws, color='green') # plt.plot(Ws, 0.5*np.sqrt(2), 'ko') # cutoff frequency plt.show() return filtered_data
import numpy as np import librosa import librosa.display import matplotlib.pyplot as plt filename = r'1.wav' # Load the example clip y, sr = librosa.load(filename) y = y - 0.97 * y from scipy import signal import numpy as np import math # b, a = signal.butter(4, 16000/sr*0.5, "highpass") # lowpass # 阶数;最大纹波允许低于通频带中的单位增益。以分贝表示,以正数表示;频率(Hz)/奈奎斯特频率(采样率*0.5) b, a = signal.cheby1(4, 5, 16000 / sr * 0.5, "highpass") # lowpass yt = signal.filtfilt(b, a, y) y = yt S, phase = librosa.magphase(librosa.stft(y=y)) cent = librosa.feature.spectral_centroid(y=y, sr=sr) print('rms.shape:', cent.shape) plt.figure() plt.subplot(211) plt.semilogy(cent.T, label='Spectral centroid') plt.ylabel('Hz') plt.xticks([]) plt.xlim([0, cent.shape[-1]]) plt.subplot(212)
def LPman(self, fil_dict): self._get_params(fil_dict) if not self._test_N(): return -1 self._save(fil_dict, sig.cheby1(self.N, self.A_PB, self.F_C, btype='low', analog=self.analog, output=self.FRMT))
def test_cheby1_7(self): # Test case for analog filter IIR = IIRDesign.cheby1(self.n, self.Rp, self.Wps, zs='s') iir = signal.cheby1(self.n, self.Rp, self.Wps, analog=True) self.assertTrue((IIR[0] == iir[0]).all() and (IIR[1] == iir[1]).all())
# sampling rate fs = 24000 # cutoffs f1 = 300 f2 = 2700 # scaling factor in bits q = 14 # scaling factor as facor... scaling_factor = 2**q # let's generate a sequence of 2nd order IIR filters #sos = signal.butter(2,[f1/fs*2,f2/fs*2],'pass',output='sos') sos = signal.cheby1(3, 0.2, [f1 / fs * 2, f2 / fs * 2], 'bandpass', output='sos') sos = np.round(sos * scaling_factor) # print coefficients for biquad in sos: for coeff in biquad: print(int(coeff), ",", sep="", end="") print(q) # plot the frequency response b, a = signal.sos2tf(sos) w, h = signal.freqz(b, a) pl.plot(w / np.pi / 2 * fs, 20 * np.log(np.abs(h))) pl.xlabel('frequency/Hz')
def BSman(self, fil_dict): self._get_params(fil_dict) if not self._test_N(): return -1 self._save(fil_dict, sig.cheby1(self.N, self.A_PB, [self.F_C,self.F_C2], btype='bandstop', analog=self.analog, output=self.FRMT))
As = 0.1 Ap = 0.9 fsl = (fpl * fph) / fsh Os = (fsh - fsl) / (fph - fpl) delta = np.sqrt((1 / As) - 1) e = np.sqrt((1 / Ap) - 1) n = (math.acosh(delta / e)) / (math.acosh(Os)) n = np.round(n) ## Funcion de transferencia Fs = 44100.0 Fn = 0.5 * Fs #Frecuencia de Nyquist rp = -10 * math.log10(0.9) b, a = signal.cheby1(n, rp, np.array([200, 6000]) / Fn, 'bandpass', analog=False) ## Respuesta en la frecuencia 0 a 1000 Hz incrementos de 10 Hz f = np.arange(0, 10000, 10) w = np.pi * f / Fn w, h = signal.freqz(b, a, w) ##Grafica pyplot.plot(f, np.abs(h)) pyplot.show()
A = 0.5 * (c.full_scale_32 - 1 ) # Half of 32 bit full scale, because noise can be added K_Noise = 1 / 50 # Gaussian noise relative std amplitude FORMAT = pyaudio.paInt32 # Signed 32 bit (Little Endian byte order) CHANNELS = int(2) byte_width = 4 bytes_size = CHANNELS * byte_width * c.N_FRAMES # Bytes in each period # fc = 500 # Filter central frequency f1 = fc / 1.4142 f2 = fc * 1.4142 # butter(N, [W1, w2] btype='bp', analog=False, output='ba') # cheby1(N, rp, [W1, W2] btype='bp', analog=False, output='ba') B_hp, A_hp = cheby1(4, 0.03, [f1 / Fnyq, f2 / Fnyq], 'bp', analog=False, output='ba') # # freqz(b, a=1, worN=None, whole=0, plot=None) w_norm, h_bp = freqz(b=B_hp, a=A_hp, worN=f_range, whole=False, plot=None) f_hz = (w_norm * Fnyq / np.pi) # if SIGNAL == "chirp": x = c.PUT_AUDIO_PEAK * chirp(t, Fmin, T, Fmax, method='linear', phi=90) / PI_OUT_GAIN # Chirp signal y = lfilter(B_hp, A_hp, x) # Chirp signal filtered with a bp if PLOT_FILTER: fig_0 = plt.figure() plt.subplot(111) plt.semilogx(f_hz[sel], 20 * np.log10(np.abs(h_bp[sel])))
def _update_canvas(self): """ Update the figure when the user changes an input value :return: """ # Get the parameters from the form filter_order = int(self.filter_order.text()) critical_frequency = int(self.critical_frequency.text()) maximum_ripple = float(self.maximum_ripple.text()) minimum_attenuation = float(self.minimum_attenuation.text()) # Get the selected filter from the form filter_type = self.filter_type.currentText() if filter_type == 'Butterworth': b, a = signal.butter(filter_order, critical_frequency, 'low', analog=True) elif filter_type == 'Chebyshev': b, a = signal.cheby1(filter_order, maximum_ripple, critical_frequency, 'low', analog=True) elif filter_type == 'Bessel': b, a = signal.bessel(filter_order, critical_frequency, 'low', analog=True, norm='phase') elif filter_type == 'Elliptic': b, a = signal.ellip(filter_order, maximum_ripple, minimum_attenuation, critical_frequency, 'low', analog=True) w, h = signal.freqs(b, a) # Clear the axes for the updated plot self.axes1.clear() # Create the line plot self.axes1.semilogx(w, 20 * log10(abs(h))) # Set the y axis limit self.axes1.set_ylim(-80, 5) # Set the x and y axis labels self.axes1.set_xlabel("Frequency (Hz)", size=12) self.axes1.set_ylabel("Amplitude (dB)", size=12) # Turn on the grid self.axes1.grid(linestyle=':', linewidth=0.5) # Set the plot title and labels self.axes1.set_title('Filter Response', size=14) # Set the tick label size self.axes1.tick_params(labelsize=12) # Update the canvas self.my_canvas.draw()
# Importing the dataset dataset = pd.read_csv(f'{file}/csv_files/bode_chevy.csv') freq = dataset.iloc[:, 0].values mag = dataset.iloc[:, 1].values Fn = 22e3 fc = 2*np.pi*Fn ordem = [8] rp = 0.5 # Grafico 1 plt.semilogx(freq, mag, label='Filtro implementado') # Grafico2 for N in ordem: b, a = signal.cheby1(N, rp, fc, 'low', analog=True) w, h = signal.freqs(b, a) plt.semilogx(w/(2*np.pi), 20 * np.log10(abs(h)), label=f'Filtro ideal') plt.title('Resposta em frequência do filtro Chevyshev') plt.xlabel('Frequencia [Hz]') plt.ylabel('Amplitude [dB]') plt.margins(0, 0.1) plt.grid(which='both', axis='both') plt.axvline(Fn, color='green') # cutoff frequency plt.axhline(-0.5, color='green') # ripple plt.legend(loc='upper left') plt.tight_layout() plt.show()
from scipy import signal import matplotlib.pyplot as plt import librosa import soundfile as sf (Frequency, array) = librosa.load('audio10.wav', sr=None) len(Frequency) plt.plot(Frequency) plt.title('Original Signal Spectrum') plt.xlabel('Frequency(Hz)') plt.ylabel('Amplitude') # plt.show() b, a = signal.cheby1(5, 3, 1000 / (0.5 * array), btype='highpass') filteredSignal = signal.lfilter(b, a, Frequency) plt.plot(filteredSignal) # plotting the signal. plt.title('Highpass Filter') plt.xlabel('Frequency(Hz)') plt.ylabel('Amplitude') # plt.show() c, d = signal.cheby1(5, 3, 380 / (0.5 * array), btype='lowpass') # ButterWorth low-filter newFilteredSignal = signal.lfilter(c, d, filteredSignal) # Applying the filter to the signal plt.plot(newFilteredSignal) # plotting the signal. plt.title('Lowpass Filter') plt.xlabel('Frequency(Hz)') plt.ylabel('Amplitude') # plt.show()
}) df.plot(x='f', logy=True, logx=True, xlim=(10, fs / 2)) def noisy_chirp(fs=44100, seconds=1.0): t = numpy.linspace(0, 1, int(seconds * fs), False) chirp = signal.chirp(t, f0=6, f1=fs / 2.0, t1=seconds, method='linear') noise = numpy.random.normal(0, 1.0, size=len(t)) sig = chirp + 0.05 * noise return t, sig FS = 32000 FILTERS = { 'cheby1-order1-lowpass': signal.cheby1(N=1, rp=3, Wn=1000, btype='lp', fs=FS, output='sos'), 'cheby1-order2-highpass': signal.cheby1(N=2, rp=3, Wn=2000, btype='hp', fs=FS, output='sos'), 'cheby1-order4-highpass': signal.cheby1(N=4, rp=3, Wn=2000, btype='hp', fs=FS, output='sos'), 'cheby1-order5-bandpass': signal.cheby1(N=5, rp=12, Wn=[2000, 4000], btype='bp', fs=FS, output='sos'), 'cheby1-order12-highpass': signal.cheby1(N=12, rp=12, Wn=4000, btype='hp', fs=FS, output='sos'), } @pytest.mark.parametrize('filtername', FILTERS.keys()) def test_iir_filter(filtername): sos = FILTERS[filtername]
def calcularPlotImpinvar(f0, fs, mode="butter", n=4, filename="out.png", title="noTitle"): w0 = 2 * pi * f0 print("f0 = ", f0) if mode == "butter": b, a = signal.butter(n, w0, 'low', analog=True) elif mode == "cheby": b, a = signal.cheby1(n, 1, w0, 'low', analog=True) sys = signal.lti(b, a) w_range = linspace(0, fs, 100000) * 2 * pi w, h = signal.freqresp(sys, w_range) # signal.freqs(b, a, 100000) w_m2 = -1 for i in range(len(w)): if 20 * log10(abs(h[i])) <= -2 and w_m2 == -1: w_m2 = w[i] if mode == "butter": b, a = signal.butter(n, w0 * (w0 / w_m2), 'low', analog=True) elif mode == "cheby": b, a = signal.cheby1(n, 1, w0 * (w0 / w_m2), 'low', analog=True) sys = signal.lti(b, a) sys_original = sys w, h = signal.freqresp(sys, w_range) f = w / 2 / pi b2, a2 = impinvar_causal(b, a, fs=fs, tol=0.0001) sys = signal.dlti(b2, a2) w2, h2 = signal.dfreqresp(sys, w_range / fs) factor = h[0] / h2[0] sys = signal.dlti(b2 / factor, a2) f2 = w2 / 2 / pi * fs CombinedPlot() \ .setTitle(title) \ .setXTitle("Frecuencia (hz)") \ .setYTitle("Amplitud (Db)") \ .addSignalPlot( signal=Senial.Senial( f, 20 * log10(abs(h)) ), color="red", name="Analógica" ).addSignalPlot( signal=Senial.Senial( f2, 20 * log10(abs(h2) * factor) ), color="blue", name="Digital método invariante al impulso" ).plot().save("output/" + filename)