def preprocess_morlet(data, metadata, notch_filter=True, downsampling_factor=32, sfreq=250, freqs=[10], n_cycles=50):
b1, a1 = signal.iirfilter(1, [59.0 / 125.0, 61.0 / 125.0], btype="bandstop")
b2, a2 = signal.iirfilter(1, 3.0 / 125.0, btype="highpass")
def do_morlet(arr):
if notch_filter:
arr = signal.lfilter(b1, a1, arr)
arr = signal.lfilter(b2, a2, arr)
cwt = wavelet_transform(
arr[:, np.newaxis], sfreq=sfreq, freqs=freqs, n_cycles=n_cycles, include_phase=False, log_mag=True
)
arr = cwt.mean(axis=1)
if downsampling_factor > 1:
decimated = signal.decimate(arr, downsampling_factor)
else:
decimated = arr
return decimated
return preprocess_general(process=do_morlet, data=data, metadata=metadata)
def preprocess_stft(data, metadata, notch_filter=True,
box_width=128, downsampling_factor=32,
sfreq=250, low_f=8, high_f=12, kaiser_beta=14):
b1, a1 = signal.iirfilter(1, [59.0/125.0, 61.0/125.0], btype='bandstop')
b2, a2 = signal.iirfilter(1, 3.0/125.0, btype='highpass')
def do_stft(arr):
if notch_filter:
arr = signal.lfilter(b1, a1, arr)
arr = signal.lfilter(b2, a2, arr)
if len(arr) < box_width:
raise ValueError("The buffer_size used by the connector should "
"be higher than box_width. buffer_size = "
"%s | box_width = %s" % (len(arr), box_width))
out = stft(arr[:, np.newaxis],
box_width=box_width, step=downsampling_factor, pad_width=0,
kaiser_beta=kaiser_beta, include_phase=False, log_mag=True)
fftfreq = np.fft.rfftfreq(box_width, d=1/float(sfreq))
good = np.logical_and(fftfreq >= low_f, fftfreq <= high_f)
out = out[:, good].mean(axis=1)
return out
return preprocess_general(process=do_stft,
data=data, metadata=metadata)
def compute_theory(stala, stalo, evla, evlo, gamma_r, gamma_s, gamma_d, iiM, tt, t1, t2, channel):
G = 6.674e-11
R = 6370000.
# station coordinates
stala *= np.pi / 180
stalo *= np.pi / 180
# event coordinates
evla *= np.pi / 180
evlo *= np.pi /180
rake = np.array([[np.cos(gamma_r), -np.sin(gamma_r), 0], [np.sin(gamma_r), np.cos(gamma_r), 0], [0, 0, 1]])
strike = np.array([[np.cos(gamma_s), np.sin(gamma_s), 0], [-np.sin(gamma_s), np.cos(gamma_s), 0], [0, 0, 1]])
dip = np.array([[np.cos(gamma_d), 0, -np.sin(gamma_d)], [0, 1, 0], [np.sin(gamma_d), 0, np.cos(gamma_d)]])
ex = strike.dot(dip).dot(np.array([0, 0, 1]))
ez = strike.dot(dip).dot(rake).dot(np.array([0, 1, 0]))
rst = R * np.array([np.cos(stala)*np.sin(stalo), np.cos(stala)*np.cos(stalo), np.sin(stala)])
rev = R * np.array([np.cos(evla)*np.sin(evlo), np.cos(evla)*np.cos(evlo), np.sin(evla)])
dr = rst - rev
er = rst / np.linalg.norm(rst)
er0 = dr / np.linalg.norm(dr)
eNS = np.array([np.sin(stala)*np.sin(stalo), np.sin(stala)*np.cos(stalo), -np.cos(stala)])
eNS = eNS / np.linalg.norm(eNS)
eWE = np.array([np.cos(stalo), -np.sin(stalo), 0.])
eWE = eWE / np.linalg.norm(eWE)
a = ex.T.dot(er0)*ez
b = ez.T.dot(er0)*ex
c = ex.T.dot(er0)*ez.T.dot(er0)*er0
vec = - 6*G / np.linalg.norm(dr)**4 * ( a + b - 5*c )
th_UD = er.T.dot(vec) * iiM
th_WE = eWE.T.dot(vec) * iiM
th_NS = eNS.T.dot(vec) * iiM
if channel == 'LHZ':
th = th_UD
elif channel == 'LHN':
th = th_NS
else:
th = th_WE
# filter band applied to the seismic data during preprocessing
fcut1 = 0.001 / (0.5 * 1.0)
[b, a] = signal.iirfilter(4, fcut1, btype='high', ftype='bessel', output='ba')
th = signal.lfilter(b, a, th)
fcut2 = 2*0.059904 / (0.5 * 1.0)
[b, a] = signal.iirfilter(8, fcut2, btype='low', ftype='bessel', output='ba')
th = signal.lfilter(b, a, th)
mask = np.nonzero( (tt >= t1*np.ones(len(tt))) * (tt <= t2*np.ones(len(tt))) )
return np.mean(th[mask]*1.0E8)
def set_sampling_ferquency(self, fs, channels, bpfilter, notchfilter):
""" Set the sampling frequency and filters for individual channels.
Parameters:
fs -- sampling frequency
channels -- list of booleans: channels[0] == True: enable filter for channel 0
bpfilter -- tuple: parameters for the band pass filter (hp, lp, fs, order) or None
notchfilter -- tuple: parameters for the band stop filter (hp, lp, fs, order) or None
"""
# we have: hp, lp, fs, order, typ
# signal.iirfilter(order/2, [hp/(fs/2), lp/(fs/2)], ftype='butter', btype='band')
# we get 18 coeffs and put them in as '<d' in the buffer
# struct.pack('<'+'d'*18, *coeffs)
# special filter: means no filter
null_filter = "\x00\x00\x00\x00\x00\x00\xf0\x3f"+"\x00\x00\x00\x00\x00\x00\x00\x00"*17
if bpfilter:
bp_hp, bp_lp, bp_fs, bp_order = bpfilter
bp_b, bp_a = iirfilter(bp_order/2, [bp_hp/(bp_fs/2), bp_lp/(bp_fs/2)], ftype='butter', btype='band')
bp_filter = list(bp_b)
bp_filter.extend(list(bp_a))
bp_filter = struct.pack("<"+"d"*18, *bp_filter)
else:
bp_filter = null_filter
if notchfilter:
bs_hp, bs_lp, bs_fs, bs_order = notchfilter
bs_b, bs_a = iirfilter(bs_order/2, [bs_hp/(bs_fs/2), bs_lp/(bs_fs/2)], ftype='butter', btype='bandstop')
bs_filter = list(bs_b)
# the notch filter has (always?) an order of 4 so fill the gaps with
# zeros
if len(bs_filter) < 9:
diff = 9 - len(bs_filter)
bs_filter.extend([0.0 for i in range(diff)])
bs_filter.extend(list(bs_a))
if len(bs_filter) < 18:
diff = 18 - len(bs_filter)
bs_filter.extend([0.0 for i in range(diff)])
bs_filter = struct.pack("<"+"d"*18, *bs_filter)
else:
bs_filter = null_filter
# set the filters for all channels
if bpfilter == notchfilter == None:
self.devh.controlMsg(CX_OUT, 0xc6, value=0x01, buffer=bp_filter)
self.devh.controlMsg(CX_OUT, 0xc7, value=0x01, buffer=bs_filter)
else:
idx = 1
for i in channels:
if i:
self.devh.controlMsg(CX_OUT, 0xc6, value=idx, buffer=bp_filter)
self.devh.controlMsg(CX_OUT, 0xc7, value=idx, buffer=bs_filter)
idx += 1
# set the sampling frequency
self.devh.controlMsg(CX_OUT, 0xb6, value=fs, buffer=0)
def __init__(self, order=3, wn=0.01, coeff_scale=1, rp=1, rs=60, ftype='butter', dtype=np.float): if order%2 == 0: print 'No even order filters allowed.' return # Filter settings self.order = order self.wn = wn self.rp = rp self.rs = rs self.dtype = dtype self.ftype = ftype self.coeff_scale = coeff_scale gammas = [] psi = np.tan(np.pi*self.wn/2.0) psi2 = psi*psi if self.ftype == 'butter': (z,p,k) = signal.iirfilter(self.order, psi, btype='lowpass', analog=1, ftype='butter', output='zpk') filter_roots = np.sort(p) elif self.ftype == 'bessel': print 'Please avoid using Bessel filters as they don\'t translate well to LWDFs.' (z,p,k) = signal.iirfilter(self.order, psi, btype='lowpass', analog=1, ftype='bessel', output='zpk') filter_roots = np.sort(p) elif self.ftype == 'cheby1': (z,p,k) = signal.iirfilter(self.order, psi, rp=1, btype='lowpass', analog=1, ftype='cheby1', output='zpk') filter_roots = np.sort(p) elif self.ftype == 'cheby2': (z,p,k) = signal.iirfilter(self.order, psi, rs=self.rs, btype='lowpass', analog=1, ftype='cheby2', output='zpk') filter_roots = np.sort(p) else: print 'Invalid filter type.' return # Separate the real pole from the complex poles real_index = 0; for i in range(self.order): if abs(filter_roots[i].imag) <= 1e-16: real_index = i break complex_roots = np.concatenate((filter_roots[0:real_index],filter_roots[real_index+1:])) # Put in the real pole's gamma value h_B = -1.0*filter_roots[real_index].real gammas.append((1.0 - h_B) / (1.0 + h_B)) # Calculate coefficients of the individual Hurwitz polynomials for i in (range((order-1)/2)): h_A = -2.0*(complex_roots[2*i].real) h_B = abs(complex_roots[2*i])**2 gammas.append((h_A - h_B - 1.0)/(h_A + h_B + 1.0)) gammas.append((1.0 - h_B) / (1.0 + h_B)) # Construct filter for i in range(self.order): self.adaptors.append(Adaptor(gammas[i],self.coeff_scale,self.dtype)) self.registers.append(0)
def __engine(self):
"""
Engine of the function
"""
# ---------------------------------------------------------------------
# Generate the base signal
self.nSmp = round(self.fR * self.tS) # The number of samples in the output signal
self.mSig = np.random.randn(self.nSigs, self.nSmp) # Generate the noise
# ---------------------------------------------------------------------
# Filter the signal with a low pass filter, if it is needed
if self.wasParamGiven('fMax') and self.wasParamGiven('fMin'):
# Design a iir low pass filter
iCFP_l = self.fMin/(0.5*self.fR) # Compute the filter parameter for the low cutoff frequency
iCFP_h = self.fMax/(0.5*self.fR) # Compute the filter parameter for the high cutoff frequency
(vN, vD) = scsig.iirfilter(self.nFiltOrd, [iCFP_l, iCFP_h], btype='bandpass', ftype=self.strFilt,
rs=self.iRs, rp=self.iRp)
# Apply the filter
self.mSig = scsig.lfilter(vN, vD, self.mSig)
elif self.wasParamGiven('fMax'):
# Design a iir low pass filter
iCFP = self.fMax/(0.5*self.fR) # Compute the filter parameter for the cutoff frequency
(vN, vD) = scsig.iirfilter(self.nFiltOrd, iCFP, btype='lowpass', ftype=self.strFilt,
rs=self.iRs, rp=self.iRp)
# Apply the filter
self.mSig = scsig.lfilter(vN, vD, self.mSig)
elif self.wasParamGiven('fMin'):
# Design a iir low pass filter
iCFP = self.fMin/(0.5*self.fR) # Compute the filter parameter for the cutoff frequency
(vN, vD) = scsig.iirfilter(self.nFiltOrd, iCFP, btype='highpass', ftype=self.strFilt,
rs=self.iRs, rp=self.iRp)
# Apply the filter
self.mSig = scsig.lfilter(vN, vD, self.mSig)
# ---------------------------------------------------------------------
# Adjust the signal power
(self.mSig, self.vP) = self._adjPower(self.mSig, self.iP)
return
def run(self):
out = 0
z1 = 0
z2 = 0
outputlist = []
for line in self.signal:
z1 = line + z1 - z2
out = self.quantization(z1)
z2 = out
outputlist.append(out)
spectrum = numpy.fft.fft(outputlist[0:0+self.fftsample])
spplot = (numpy.sqrt(numpy.power(spectrum.real,2)+numpy.power(spectrum.imag,2)))
freqlist = numpy.fft.fftfreq(self.fftsample,d=1/self.samplerate)
b, a = signal.iirfilter(4, 1000 / (self.samplerate / 2), btype = 'lowpass', analog = False, ftype = 'butter', output = 'ba')
w,h = signal.freqz(b,a,self.fftsample)
bpltlist = spplot
#bpltlist *= abs(h)
print len(spplot)
print spplot
plt.plot(freqlist[0:self.fftsample/2],spplot[0:self.fftsample/2])
plt.axis([0, self.samplerate/2.0, 0, 500])
plt.xlim()
plt.xlabel("frequency [Hz]")
plt.ylabel("amplitude spectrum")
plt.show()
def bandpass(data, freqmin, freqmax, df, corners=4, zerophase=False):
"""
Butterworth-Bandpass Filter.
Filter data from ``freqmin`` to ``freqmax`` using ``corners`` corners.
:param data: Data to filter, type numpy.ndarray.
:param freqmin: Pass band low corner frequency.
:param freqmax: Pass band high corner frequency.
:param df: Sampling rate in Hz.
:param corners: Filter corners / orders.
:param zerophase: If True, apply filter once forwards and once backwards.
This results in twice the number of corners but zero phase shift in
the resulting filtered trace.
:return: Filtered data.
"""
fe = 0.5 * df
low = freqmin / fe
high = freqmax / fe
# raise for some bad scenarios
if high > 1:
high = 1.0
msg = "Selected high corner frequency is above Nyquist. " + \
"Setting Nyquist as high corner."
warnings.warn(msg)
if low > 1:
msg = "Selected low corner frequency is above Nyquist."
raise ValueError(msg)
[b, a] = iirfilter(corners, [low, high], btype='band',
ftype='butter', output='ba')
if zerophase:
firstpass = lfilter(b, a, data)
return lfilter(b, a, firstpass[::-1])[::-1]
else:
return lfilter(b, a, data)
def update_plots(self, fs, data):
self.current_update += 1
data = signal.detrend(data.ravel())
# Plot RMS
if self._coefs is None:
self._coefs = signal.iirfilter(2, (400.0/(fs/2), 40e3/(fs/2)))
b, a = self._coefs
self._zf = signal.lfiltic(b, a, data[:len(a)-1], data[:len(b)-1])
b, a = self._coefs
data, self._zf = signal.lfilter(b, a, data, zi=self._zf)
rms = np.mean(data**2)**0.5
db_rms = db(rms)-self.paradigm.mic_sens_dbv-db(20e-6)
self.append_data(time=self.current_time, rms=db_rms)
self.current_time += len(data)/fs
self.current_spl = db_rms
self.current_spl_average = self.rms_data.get_data('rms')[-60:].mean()
self.overall_spl_average = self.rms_data.get_data('rms').mean()
w_frequency = psd_freq(data, fs)
w_psd = psd(data, fs, 'hamming')
w_psd_db = db(w_psd)-self.paradigm.mic_sens_dbv-db(20e-6)
self.rms_data.update_data(frequency=w_frequency, psd=w_psd_db)
def __init__(self, fp, fs, gpass, gstop, ftype, btype):
#Variables init.
self.fp = fp
self.fs = fs
self.gpass = gpass
self.gstop = gstop
self.ftype = ftype
self.btype = btype
#Filter type for plot's title.
types_dict = {"butter":"Butterworth", "cheby1":"Chebyshev I", "cheby2":"Chebyshev II", "ellip": "Cauer"}
self.ftype_plot = types_dict[ftype]
self.__wsk()
self.__filter_order()
#Designing filter.
(self.b, self.a) = signal.iirfilter(self.ord,
self.wn,
rp=self.gpass,
rs=self.gstop,
btype=self.btype,
analog=True,
output='ba',
ftype=ftype)
#Frequency response of analog filter.
(self.w, self.h) = signal.freqs(self.b, self.a, worN=1000)
#Denormalizing variabels for ploting. Pulsation to frequency.
self.w = (self.w * (self.sampling_w / 2)) / (2 * pi)
self.wn = (self.wn * (self.sampling_w / 2)) / (2 * pi)
def __init__(self, order, cutoff, btype='bandpass', axis=1):
if btype == 'bandpass' or btype == 'bandstop':
assert len(cutoff) == 2, 'Please supply a low and high cutoff.'
if btype == 'bandpass' or btype == 'bandstop':
design_func = lambda s: signal.iirfilter(order, [cutoff[0]/(s/2.0),
cutoff[1]/(s/2.0)], btype=btype)
else:
design_func = lambda s: signal.iirfilter(order, cutoff/(s/2.0),
btype=btype)
self.order = order
self.cutoff = cutoff
self.btype = btype
Filter.__init__(self, design_func, axis)
def compute_filter(self): freqRatio = self.frequency / self.nyquist print self.frequency, self.nyquist, freqRatio print type(self.frequency), type(self.nyquist), type(freqRatio) wn = freqRatio r = 0.1 B, A = np.zeros(3), np.zeros(3) A[0],A[1],A[2] = 1.0, -2.0*r*np.cos(2*np.pi*wn), r*r B[0],B[1],B[2] = 1.0, -2.0*np.cos(2*np.pi*wn), 1.0 self._filter_b = B self._filter_a = A #%Compute zeros #zeros = np.array([np.exp(0+1j *np.pi*freqRatio ), np.exp( 0-1j*np.pi*freqRatio )]) #%Compute poles #poles = (1-self.notchWidth) * zeros #self._filter_b = np.poly( zeros ) # Get moving average filter coefficients #self._filter_a = np.poly( poles ) # Get autoregressive filter coefficients self._filter_b, self._filter_a = iirfilter(4, (45. / self.nyquist, 55. / self.nyquist), 'bandstop')
def lowpass(freq, df, corners=4):
"""
Butterworth-Lowpass Filter.
Filter data removing data over certain frequency ``freq`` using ``corners``
corners.
The filter uses :func:`scipy.signal.iirfilter` (for design)
and :func:`scipy.signal.sosfilt` (for applying the filter).
:type data: numpy.ndarray
:param data: Data to filter.
:param freq: Filter corner frequency.
:param df: Sampling rate in Hz.
:param corners: Filter corners / order.
:param zerophase: If True, apply filter once forwards and once backwards.
This results in twice the number of corners but zero phase shift in
the resulting filtered trace.
:return: Filtered data.
"""
fe = 0.5 * df
f = freq / fe
# raise for some bad scenarios
if f > 1:
f = 1.0
msg = "Selected corner frequency is above Nyquist. " + \
"Setting Nyquist as high corner."
warnings.warn(msg)
z, p, k = iirfilter(corners, f, btype='lowpass', ftype='butter',
output='zpk')
sos = zpk2sos(z, p, k)
return sos
def highpass(signal, Fs, fc=constants.fc_hp, plot=False):
'''
Filter out the really low frequencies, default is below 50Hz
'''
# have some predefined parameters
rp = 5 # minimum ripple in dB in pass-band
rs = 60 # minimum attenuation in dB in stop-band
n = 4 # order of the filter
type = 'butter'
# normalized cut-off frequency
wc = 2. * fc / Fs
# design the filter
from scipy.signal import iirfilter, lfilter, freqz
b, a = iirfilter(n, Wn=wc, rp=rp, rs=rs, btype='highpass', ftype=type)
# plot frequency response of filter if requested
if (plot):
import matplotlib.pyplot as plt
w, h = freqz(b, a)
plt.figure()
plt.title('Digital filter frequency response')
plt.plot(w, 20 * np.log10(np.abs(h)))
plt.title('Digital filter frequency response')
plt.ylabel('Amplitude Response [dB]')
plt.xlabel('Frequency (rad/sample)')
plt.grid()
# apply the filter
signal = lfilter(b, a, signal.copy())
return signal
def lowpass(data, freq, df, corners=4, zerophase=False):
"""
Butterworth-Lowpass Filter.
Filter data removing data over certain frequency ``freq`` using ``corners``
corners.
:param data: Data to filter, type numpy.ndarray.
:param freq: Filter corner frequency.
:param df: Sampling rate in Hz.
:param corners: Filter corners / orders.
:param zerophase: If True, apply filter once forwards and once backwards.
This results in twice the number of corners but zero phase shift in
the resulting filtered trace.
:return: Filtered data.
"""
fe = 0.5 * df
f = freq / fe
# raise for some bad scenarios
if f > 1:
f = 1.0
msg = "Selected corner frequency is above Nyquist. " + \
"Setting Nyquist as high corner."
warnings.warn(msg)
[b, a] = iirfilter(corners, f, btype='lowpass', ftype='butter',
output='ba')
if zerophase:
firstpass = lfilter(b, a, data)
return lfilter(b, a, firstpass[::-1])[::-1]
else:
return lfilter(b, a, data)
def _get_a(self):
# Combine value/units from GUI to form actual cutoff frequency.
val = self.filter_cutoff
units = self.filter_cutoff_units
if (units == "Hz"):
fc = val
elif (units == "kHz"):
fc = val * 1e3
elif (units == "MHz"):
fc = val * 1e6
else:
fc = val * 1e9
# Generate the filter coefficients.
if (self.filter_type == "FIR"):
w = fc/(self.sample_rate/2)
b = firwin(self.Ntaps, w)
a = [1]
elif (self.filter_type == "IIR"):
(b, a) = iirfilter(self.Ntaps - 1, fc/(self.sample_rate/2), btype='lowpass')
else:
a = self.usr_a[0]
b = self.usr_b[0]
if (self.filter_type != "custom"):
self.a_str = reduce(lambda string, item: string + "%+06.3f "%item, a, "")
self.b_str = reduce(lambda string, item: string + "%+06.3f "%item, b, "")
self.b = b
return a
def highpass(data, freq, df, corners=4, zerophase=False):
"""
Butterworth-Highpass Filter.
Filter data removing data below certain frequency ``freq`` using
``corners`` corners.
:param data: Data to filter, type numpy.ndarray.
:param freq: Filter corner frequency.
:param df: Sampling rate in Hz.
:param corners: Filter corners. Note: This is twice the value of PITSA's
filter sections
:param zerophase: If True, apply filter once forwards and once backwards.
This results in twice the number of corners but zero phase shift in
the resulting filtered trace.
:return: Filtered data.
"""
fe = 0.5 * df
f = freq / fe
# raise for some bad scenarios
if f > 1:
msg = "Selected corner frequency is above Nyquist."
raise ValueError(msg)
[b, a] = iirfilter(corners, f, btype='highpass', ftype='butter',
output='ba')
if zerophase:
firstpass = lfilter(b, a, data)
return lfilter(b, a, firstpass[::-1])[::-1]
else:
return lfilter(b, a, data)
def iir_filter_coefs(order=3, cutoff=np.array([7.0, 12, 0]),
btype='band', nyq=SAMPLING_RATE/2):
"""Compute IIR filter coefficients.
Parameters
----------
order : int
Filter order
cutoff : numpy.array
Array with filter cutoff frequencies in Hertz
btype : 'band'
Filter type
nyq : float
Nyquist frequency in Hertz
Returns
-------
b : numpy.array
Filter coefficients
a : numpy.array
Filter coefficients
"""
with warnings.catch_warnings():
warnings.filterwarnings("error")
try:
b, a = signal.iirfilter(order, cutoff/nyq, btype=btype)
except BadCoefficients:
raise
return b, a
def highpass(data, freq, df, corners=4, zerophase=False):
"""
Butterworth-Highpass Filter.
Filter data removing data below certain frequency ``freq`` using
``corners`` corners.
The filter uses :func:`scipy.signal.iirfilter` (for design)
and :func:`scipy.signal.sosfilt` (for applying the filter).
:type data: numpy.ndarray
:param data: Data to filter.
:param freq: Filter corner frequency.
:param df: Sampling rate in Hz.
:param corners: Filter corners / order.
:param zerophase: If True, apply filter once forwards and once backwards.
This results in twice the number of corners but zero phase shift in
the resulting filtered trace.
:return: Filtered data.
"""
fe = 0.5 * df
f = freq / fe
# raise for some bad scenarios
if f > 1:
msg = "Selected corner frequency is above Nyquist."
raise ValueError(msg)
z, p, k = iirfilter(corners, f, btype='highpass', ftype='butter',
output='zpk')
sos = zpk2sos(z, p, k)
if zerophase:
firstpass = sosfilt(sos, data)
return sosfilt(sos, firstpass[::-1])[::-1]
else:
return sosfilt(sos, data)
def lowpass(y):
"""Signal smoothing by low pass filtering.
This method is based on the application of a butterworth low pas filter of order 5 to the signal. It skims out the
higher frequencies that are responsible for abrupt changes thus smoothing the signal. Output edges are different
from input edges.
input:
y: input signal (type: list)
output:
y_smooth : filtered signal (type: ndarray)
"""
from scipy.fftpack import fftfreq, fft
from scipy.signal import filtfilt, iirfilter
from numpy import abs, amax
frequency = fftfreq(len(y))
spectrum = abs(fft(y, n=None, axis=-1, overwrite_x=False))
Wn = amax(frequency) / 10
N = 5 # Order of the filter
b, a = iirfilter(N, Wn, rp=None, rs=None, btype="low", analog=False, ftype="butter", output="ba")
y_smooth = filtfilt(b, a, y, axis=-1, padtype=None)
return y_smooth
def __init__(self):
self.filter_parameters = filter_parameters()
# self.num, self.denom = iirdesign(wp=[self.filter_parameters.lowcut, self.filter_parameters.highcut], ws=[0.005,0.35], gpass=self.filter_parameters.mloss, gstop=self.filter_parameters.matten, analog=False, ftype='butter', output='ba')
# self.num, self.denom = iirdesign(wp=[self.filter_parameters.lowcut, self.filter_parameters.highcut], ws=[0.01,0.35], gpass=0.05, gstop=5, analog=False, ftype='cheby1', output='ba')
# self.num, self.denom = iirdesign(wp=[self.filter_parameters.lowcut, self.filter_parameters.highcut], ws=[0.005,0.35], gpass=1.7, gstop=20, analog=False, ftype='cheby2', output='ba')
# self.num, self.denom = iirdesign(wp=[self.filter_parameters.lowcut, self.filter_parameters.highcut], ws=[0.005,0.35], gpass=0.4, gstop=28, analog=False, ftype='ellip', output='ba')
self.num, self.denom = iirfilter(5, [self.filter_parameters.lowcut, self.filter_parameters.highcut], btype='bandpass', analog=False, ftype='bessel', output='ba')
def noise(t, amplitude, center_frequency, bandwidth):
noise = np.random.uniform(low=-1, high=1, size=len(t))
fl = center_frequency-bandwidth
fh = center_frequency+bandwidth
Wn = np.divide([fl, fh], fs/2.)
b, a = iirfilter(8, Wn)
return filtfilt(b, a, amplitude*noise)
def lock_butter(self, N, f3dB, t_exclude=0, f0=None, print_response=True):
t = self.t
fs = self.fs
nyq = fs / 2.
f3dB = f3dB / nyq
self.iir = ba = signal.iirfilter(N, f3dB, btype='low')
if f0 is None:
self.f0 = f0 = self.f0_est
self.z = z = signal.lfilter(self.iir[0], self.iir[1], self.z)
# TODO: Fix accounting on final / initial point
m = self.m
self.m = self.m & (t >= (t[m][0] + t_exclude)) & (t < (t[m][-1] - t_exclude))
self.A = abs(self.z)
self.phi = np.angle(self.z)
if print_response:
w, rep = signal.freqz(self.iir[0], self.iir[1],
worN=np.pi*np.array([0., f3dB/2, f3dB,
0.5*f0/nyq, f0/nyq, 1.]))
print("Response:")
_print_magnitude_data(w, rep, fs)
def test_slowsphere(self):
'''
When the input is stationary, the result should be similar to the
symmetrical whitening transform but no low-frequency changes should
exist.
'''
# init
S = np.random.randn(1e4, 4)
A = np.where(np.eye(4), 1, np.random.rand(4, 4))
xs = np.dot(S, A)
xs = xs-np.mean(xs, axis=0)
# perform slow sphering
xs2 = slow_sphere(xs, signal.iirfilter(2, .1, btype='low'), 10)
# test slowness property
wstep = 20
sigs = np.asarray([cov0(xs2[i:i+wstep]) for i in
range(0, xs2.shape[0], wstep)])
spec = np.log(np.abs(np.apply_along_axis(
lambda x: np.mean(np.abs(stft(x, 256, 256)), axis=0), 0, sigs)))
self.assert_(np.mean(spec[1:10]) < np.mean(spec[10:]))
# test whiteness property
np.testing.assert_almost_equal(
np.cov(xs2, rowvar=False), np.eye(4), decimal=1)
# test that whitening preserves channel mapping
np.testing.assert_equal(
np.argmax(np.corrcoef(S.T, xs2.T)[:4, 4:], axis=1),
np.arange(4))
def __init__(self, order=2, freq=0.7,y=[],x=[]):
self.b,self.a=iirfilter(order, freq, btype="lowpass")
if len(y)>0:
print "here"
self.z=lfiltic(self.b,self.a, y)
else:
self.z=array([0.]*order)
self.z=lfiltic(self.b,self.a, y,x=x)
def main(*args):
tr = {}
whitenoise = std.vector("double")()
for i in range(8196):
whitenoise.push_back(random.gauss(0,1))
wn = [] #white noise
for i in range(whitenoise.size()):
wn.append(whitenoise[i])
tr['whitenoise'] = wn
r2hc = KRealToHalfComplexDFT()
r2hc.SetInputPulse(whitenoise)
print 'real to half complex white noise', r2hc.RunProcess()
hcp = KHalfComplexPower()
hcp.SetInputPulse(r2hc.GetOutputPulse(), r2hc.GetOutputPulseSize())
print 'power white noise', hcp.RunProcess()
wnp = [] #white noise power
for i in range(hcp.GetOutputPulseSize()):
wnp.append(hcp.GetOutputPulse()[i])
tr['whitenoisepower'] = wnp
order = 4
(b,a) = sig.iirfilter(order,0.1, btype='lowpass')
tr['b'] = b
tr['a'] = a
tr['filter order'] = order
filter = KIIRFourthOrder(a[1], a[2], a[3], a[4], b[0], b[1], b[2], b[3], b[4])
filter.SetInputPulse(whitenoise)
print 'run filter', filter.RunProcess()
filteredpulse = []
for i in range(filter.GetOutputPulseSize()):
filteredpulse.append(filter.GetOutputPulse()[i])
tr['filteredpulse'] = filteredpulse
r2hc.SetInputPulse(filter.GetOutputPulse(), filter.GetOutputPulseSize())
r2hc.RunProcess()
hcp.SetInputPulse(r2hc.GetOutputPulse(), r2hc.GetOutputPulseSize())
print 'calculate power of filtered noise', hcp.RunProcess()
fp = []
for i in range(hcp.GetOutputPulseSize()):
fp.append(hcp.GetOutputPulse()[i])
tr['filteredpower'] = fp
return tr
def iirfilter(N, Wn, rp, rs, btype, ftype, target):
b, a = signal.iirfilter(N, Wn, rp, rs, btype, ftype=ftype)
if np.any(np.abs(np.roots(a)) > 1):
raise ValueError, 'Unstable filter coefficients'
zf = signal.lfilter_zi(b, a)
while True:
y = (yield)
y, zf = signal.lfilter(b, a, y, zi=zf)
target(y)
def test_lp(self):
b, a = signal.iirfilter(4, [.1], btype='low')
df = filtering.filtfilt_rec(self.d, (b, a))
spec = np.abs(np.fft.rfft(df.data, axis=1))
# verify that there is more power in the lowest 10%
pass_p = np.mean(spec[:, :self.d.ninstances/10], axis=1)
stop_p = np.mean(spec[:, self.d.ninstances/10:], axis=1)
self.assert_(((pass_p/stop_p) > 20).all())
def scatter(filename, thrs, nchannels=2, chnl=5):
b, a = iirfilter(1, (0.002, 0.05))
with trace_gen(filename, nchannels, chnl) as gen:
data = [(sum(event[thrs:thrs + 180]),
min(filtfilt(b, a, event)[thrs:thrs + 180]) - 200)
for event in gen if max(filtfilt(b, a, event)[:20]) < 400]
int_data = zip(*data)[0]
min_data = zip(*data)[1]
return int_data, min_data
def lowpass_scatter(filename, thrs, nchannels=2):
b, a = iirfilter(1, 0.05, btype='lowpass')
with trace_gen(filename, nchannels) as gen:
data = [(sum(event[thrs:thrs + 180]),
min(filtfilt(b, a, event)[thrs:thrs + 180]) - 200)
for event in gen]
int_data = zip(*data)[0]
min_data = zip(*data)[1]
return int_data, min_data
def filter(data, btype, band, sr, corners=4, zerophase=True):
# btype: lowpass, highpass, band
fe = 0.5 * sr
z, p, k = iirfilter(corners,
band / fe,
btype=btype,
ftype='butter',
output='zpk')
sos = zpk2sos(z, p, k)
if zerophase:
firstpass = sosfilt(sos, data)
if len(data.shape) == 1:
return sosfilt(sos, firstpass[::-1])[::-1]
else:
return np.fliplr(sosfilt(sos, np.fliplr(firstpass)))
else:
return sosfilt(sos, data)
def bessel_filter(data,
freqmin,
freqmax,
sampling_rate,
corners=4,
zerophase=False):
fe = 0.5 * sampling_rate
low = freqmin / fe
high = freqmax / fe
z, p, k = signal.iirfilter(corners, [low, high],
btype='bandpass',
ftype='bessel',
output='zpk')
sos = signal.zpk2sos(z, p, k)
if zerophase:
firstpass = signal.sosfilt(sos, data)
return signal.sosfilt(sos, firstpass[::-1])[::-1]
else:
return signal.sosfilt(sos, data)
def iir_design(band_frequency,
samplerate,
order=1): # the ban frequency is the middel fre
b = []
a = []
fre = band_frequency / (samplerate / 2)
for i in range(1, len(band_frequency) - 1):
b_, a_ = signal.iirfilter(order, [
fre[i] - (fre[i] - fre[i - 1]) / 2, fre[i] +
(fre[i + 1] - fre[i]) / 2
],
btype='bandpass',
output='ba')
# b_, a_ = signal.iirfilter(order, [fre[i-1], fre[i+1]-0.001],
# btype='bandpass', output='ba')
# b_, a_ = signal.cheby1(order, 1, [fre[i] - (fre[i]-fre[i-1])/2, fre[i]+ (fre[i+1]-fre[i])/2],
# btype='bandpass', output='ba')
b.append(b_)
a.append(a_)
return b, a
def filterProc(data, fs, type, ftype="butter", cutFreq=2500.0):
"""
data: sound array
rate: RATE(fs)
type: 'bandpass', 'lowpass', 'highpass', 'bandstop'
ftype: Butterworth: 'butter', ChebyshevI: 'cheby1', ChebyshevII: 'cheby2', Cauer/elliptic: 'ellip', Bessel/Thomson: 'bessel'
"""
nyq = fs / 2.0 # nyquist freq
fc = cutFreq / nyq # cut off freq
# IIR Filtering
b, a = signal.iirfilter(3,
fc,
btype=type,
analog=False,
ftype=ftype,
output='ba')
sound = lfilter(b, a, data) #x:input，y:output, b,a:filter coefficient
return sound
def get_filter_freqs(filter_type, freqmin, freqmax, sampling_rate, **kwargs):
'''
Returns frequency band information of the filter used in cross
correlation delay time measurements.
args--------------------------------------------------------------------------
filter_type: type of filter used (e.g., bandpass, gaussian etc...)
freqmin: minimum frequency of filter (in Hz)
freqmax: maximum frequency of filter (in Hz)
sampling_rate: sampling rate of seismograms (in Hz)
kwargs-------------------------------------------------------------------------
corners: number of corners used in filter (if bandpass). default = 2
returns-----------------------------------------------------------------------
omega: frequency axis (rad/s)
amp: frequency response of filter
'''
plot = kwargs.get('plot', False)
corners = kwargs.get('corners', 2)
nyquist = 0.5 * sampling_rate
fmin = freqmin / nyquist
fmax = freqmax / nyquist
if filter_type == 'bandpass':
b, a = iirfilter(corners, [fmin, fmax], btype='band', ftype='butter')
freq_range = np.linspace(0, 0.15, 200)
w, h = freqz(b, a, worN=freq_range)
omega = sampling_rate * w
omega_hz = (sampling_rate * w) / (2 * np.pi)
amp = abs(h)
if plot:
fig, axes = plt.subplots(2)
axes[0].plot(omega, amp)
axes[0].set_xlabel('frequency (rad/s)')
axes[0].set_ylabel('amplitude')
axes[1].plot(omega_hz, amp)
axes[1].set_xlabel('frequency (Hz)')
axes[1].set_ylabel('amplitude')
return omega, amp
def get_data(event_map,
splitter,
time_window=(200., 300.),
sample_rate=200,
channel='TP8',
dc=False,
filter=False):
x_train, y_train = [], []
x_test, y_test = [], []
labelled = 'Classification' in event_map.dimension_labels
start, stop = float(time_window[0]) / 1000, float(time_window[1]) / 1000
for (k, sample), train in zip(event_map.items(), splitter):
if labelled:
label = k[3]
# Design and apply the bandpass filter
if filter:
a, b = signal.iirfilter(
3, [0.5 / (sample_rate / 2.0), 100 / (sample_rate / 2.0)])
sample.data[channel] = signal.filtfilt(a,
b,
np.array(
sample.data[channel]),
axis=0)
baseline = np.array(
sample.data[(0 <= sample.data['Time'])
& (sample.data['Time'] < 100)][channel]).mean()
data = np.array(sample.data[(start <= sample.data['Time'])
& (sample.data['Time'] < stop)][channel])
data = data if dc else data - baseline
if train:
x_train.append(data)
if labelled:
y_train.append(label)
else:
x_test.append(data)
if labelled:
y_test.append(label)
return np.vstack(x_train), np.array(y_train), np.vstack(x_test) if len(
x_test) else x_test, np.array(y_test)
def __init__(self, cutoff_freq, filter_type, s_rate, n_chan, order=5):
"""
Args:
cutoff_freq (Union[float, tuple]): cutoff frequency (frequencies) for the filter
filter_type (str): Fitler type ['lowpass', 'highpass', 'bandpass', 'notch']
s_rate (Union[float, int]): sampling rate of the signal
order (int): Filter order (default value: 5)
n_chan (int): Number of channels
"""
self.s_rate = np.float(s_rate)
nyq_freq = self.s_rate / 2.
self.filter_type = filter_type
self.filter_param = None
if filter_type is 'lowpass':
hc_freq = cutoff_freq / nyq_freq
b, a = butter(order, hc_freq, btype='lowpass')
zi = np.zeros((n_chan, order))
elif filter_type is 'highpass':
lc_freq = cutoff_freq / nyq_freq
b, a = butter(order, lc_freq, btype='highpass')
zi = np.zeros((n_chan, order))
elif filter_type is 'bandpass':
if cutoff_freq[0] >= cutoff_freq[1]:
raise ValueError("High cutoff frequency must be larger than low cutoff frequency.")
lc_freq = cutoff_freq[0] / nyq_freq
hc_freq = cutoff_freq[1] / nyq_freq
if lc_freq <= 0.003:
raise ValueError('Transient band for low cutoff frequency is too narrow. Please try with larger values.')
b, a = butter(order, [lc_freq, hc_freq], btype='band')
zi = np.zeros((n_chan, order * 2))
elif filter_type is 'notch':
lc_freq = (cutoff_freq - 2) / nyq_freq
hc_freq = (cutoff_freq + 2) / nyq_freq
b, a = iirfilter(5, [lc_freq, hc_freq], btype='bandstop', ftype='butter')
zi = np.zeros((n_chan, 10))
else:
raise ValueError('Unknown filter type: {}'.format(filter_type))
self.filter_param = {'a': a, 'b': b, 'zi': zi}
def __init__(self,
N=2,
Wn=[49e6, 51e6],
rp=0.01,
rs=100,
btype='band',
ftype='ellip',
fs=1e9):
# 为避免麻烦，不继承 baFilter.__init__ 函数，只继承其他函数
# 默认参数是一个50MHz的 ellip 滤波器
# 配置字典, default: output='ba',analog=False,
self.dict = dict(N=N,
Wn=Wn,
rp=rp,
rs=rs,
btype=btype,
analog=False,
ftype=ftype,
output='ba',
fs=fs)
self.ba = signal.iirfilter(**self.dict)
def Implement_Notch_Filter(self,
time,
data,
band=20,
freq=60,
ripple=100,
order=2,
filter_type='butter'):
fs = 1 / time
nyq = fs / 2.0
low = freq - band / 2.0
high = freq + band / 2.0
low = low / nyq
high = high / nyq
b, a = iirfilter(order, [low, high],
rp=ripple,
btype='bandstop',
analog=False,
ftype=filter_type)
filtered_data = lfilter(b, a, data)
return filtered_data
def bandstop_iirfilter(f_remove, bandwidth, order, fs, filter_type='butter'):
"""
Design an IIR (infinite impulse response) bandstop filter using scipy.signal.iirfilter
:param f_remove: the center frequency of the band
:param bandwidth: the bandwidth of the filter
:param order: the order of the filter
:param fs: the sampling frequency of the signal
:param filter_type: the type of filter, default is 'butter'
:returns b: the numerator polynomial of the filter
:returns a: the denominator polynomial of the filter
"""
low, high = calculate_edge_freqs(f_remove, bandwidth, fs)
b, a = signal.iirfilter(order, [low, high],
btype='bandstop',
analog=False,
ftype=filter_type)
return (b, a)
def bandpass(data, band, sr, corners=4, zerophase=True):
freqmin, freqmax = band
fe = 0.5 * sr
low = freqmin / fe
high = freqmax / fe
z, p, k = iirfilter(corners, [low, high],
btype='band',
ftype='butter',
output='zpk')
sos = zpk2sos(z, p, k)
if zerophase:
firstpass = sosfilt(sos, data)
if len(data.shape) == 1:
return sosfilt(sos, firstpass[::-1])[::-1]
else:
return np.fliplr(sosfilt(sos, np.fliplr(firstpass)))
else:
return sosfilt(sos, data)
def bandstop(data, freqmin, freqmax, df, corners=4, zerophase=False):
"""
Butterworth-Bandstop Filter.
Filter data removing data between frequencies ``freqmin`` and ``freqmax``
using ``corners`` corners.
The filter uses :func:`scipy.signal.iirfilter` (for design)
and :func:`scipy.signal.sosfilt` (for applying the filter).
:type data: numpy.ndarray
:param data: Data to filter.
:param freqmin: Stop band low corner frequency.
:param freqmax: Stop band high corner frequency.
:param df: Sampling rate in Hz.
:param corners: Filter corners / order.
:param zerophase: If True, apply filter once forwards and once backwards.
This results in twice the number of corners but zero phase shift in
the resulting filtered trace.
:return: Filtered data.
"""
fe = 0.5 * df
low = freqmin / fe
high = freqmax / fe
# raise for some bad scenarios
if high > 1:
high = 1.0
msg = "Selected high corner frequency is above Nyquist. " + \
"Setting Nyquist as high corner."
warnings.warn(msg)
if low > 1:
msg = "Selected low corner frequency is above Nyquist."
raise ValueError(msg)
z, p, k = iirfilter(corners, [low, high],
btype='bandstop', ftype='butter', output='zpk')
sos = zpk2sos(z, p, k)
if zerophase:
firstpass = sosfilt(sos, data)
return sosfilt(sos, firstpass[::-1])[::-1]
else:
return sosfilt(sos, data)
def bandpass(freqmin, freqmax, df, corners=4):
"""
From obspy with modification.
Butterworth-Bandpass Filter.
Filter data from ``freqmin`` to ``freqmax`` using ``corners``
corners.
The filter uses :func:`scipy.signal.iirfilter` (for design)
and :func:`scipy.signal.sosfilt` (for applying the filter).
:type data: numpy.ndarray
:param data: Data to filter.
:param freqmin: Pass band low corner frequency.
:param freqmax: Pass band high corner frequency.
:param df: Sampling rate in Hz.
:param corners: Filter corners / order.
:param zerophase: If True, apply filter once forwards and once backwards.
This results in twice the filter order but zero phase shift in
the resulting filtered trace.
:return: Filtered data.
"""
fe = 0.5 * df
low = freqmin / fe
high = freqmax / fe
# raise for some bad scenarios
if high > 1:
high = 1.0
msg = "Selected high corner frequency is above Nyquist. " + \
"Setting Nyquist as high corner."
warnings.warn(msg)
if low > 1:
msg = "Selected low corner frequency is above Nyquist."
raise ValueError(msg)
z, p, k = iirfilter(corners, [low, high],
btype='band',
ftype='butter',
output='zpk')
sos = zpk2sos(z, p, k)
return sos
def bandpass(data, freqmin, freqmax, df, corners=4, zerophase=False):
"""
Butterworth-Bandpass Filter.
Filter data from ``freqmin`` to ``freqmax`` using ``corners``
corners.
The filter uses :func:`scipy.signal.iirfilter` (for design)
and :func:`scipy.signal.lfilter` (for applying the filter).
:type data: numpy.ndarray
:param data: Data to filter.
:param freqmin: Pass band low corner frequency.
:param freqmax: Pass band high corner frequency.
:param df: Sampling rate in Hz.
:param corners: Filter corners / order.
:param zerophase: If True, apply filter once forwards and once backwards.
This results in twice the filter order but zero phase shift in
the resulting filtered trace.
:return: Filtered data.
"""
fe = 0.5 * df
low = freqmin / fe
high = freqmax / fe
# raise for some bad scenarios
if high > 1:
high = 1.0
msg = "Selected high corner frequency is above Nyquist. " + \
"Setting Nyquist as high corner."
warnings.warn(msg)
if low > 1:
msg = "Selected low corner frequency is above Nyquist."
raise ValueError(msg)
[b, a] = iirfilter(corners, [low, high], btype='band',
ftype='butter', output='ba')
if zerophase:
firstpass = lfilter(b, a, data)
return lfilter(b, a, firstpass[::-1])[::-1]
else:
return lfilter(b, a, data)
def psg_highpass(cutoff, fs, order=5, plot_opt=0):
nyq = 0.5 * fs
normal_cutoff = cutoff / nyq
sos = iirfilter(order,
normal_cutoff,
rp=1,
rs=40,
btype='highpass',
analog=False,
output='sos',
ftype='ellip')
if plot_opt == 1:
w, h = sosfreqz(sos)
plt.semilogx(w * fs / (2 * np.pi), 20 * np.log10(abs(h)))
plt.title('Filter frequency response')
plt.xlabel('Frequency [radians / second]')
plt.ylabel('Amplitude [dB]')
plt.margins(0, 0.1)
plt.grid(which='both', axis='both')
plt.axvline(cutoff, color='green') # cutoff frequency
plt.show()
return sos
def bandstop(data, freqmin, freqmax, df, corners=4, zerophase=False):
"""
Butterworth-Bandstop Filter.
Filter data removing data between frequencies ``freqmin`` and ``freqmax``
using ``corners`` corners.
:param data: Data to filter, type numpy.ndarray.
:param freqmin: Stop band low corner frequency.
:param freqmax: Stop band high corner frequency.
:param df: Sampling rate in Hz.
:param corners: Filter corners. Note: This is twice the value of PITSA's
filter sections
:param zerophase: If True, apply filter once forwards and once backwards.
This results in twice the number of corners but zero phase shift in
the resulting filtered trace.
:return: Filtered data.
"""
fe = 0.5 * df
low = freqmin / fe
high = freqmax / fe
# raise for some bad scenarios
if high > 1:
high = 1.0
msg = "Selected high corner frequency is above Nyquist. " + \
"Setting Nyquist as high corner."
warnings.warn(msg)
if low > 1:
msg = "Selected low corner frequency is above Nyquist."
raise ValueError(msg)
[b, a] = iirfilter(corners, [low, high],
btype='bandstop',
ftype='butter',
output='ba')
if zerophase:
firstpass = lfilter(b, a, data)
return lfilter(b, a, firstpass[::-1])[::-1]
else:
return lfilter(b, a, data)
def __init__(self,
fl,
fh,
srate,
forder,
filt_type='iir',
band_type='band'):
nyq = 0.5 * srate
low = fl / nyq
high = fh / nyq
if filt_type == 'iir':
# self.b, self.a = sp.butter(self.filter_order, [low, high],
# btype='band')
self.b, self.a = sp.iirfilter(forder, [low, high], btype=band_type)
elif filt_type == 'fir':
self.b = sp.firwin(forder, [low, high],
window='hamming',
pass_zero=False)
self.a = [1]
def bandpass(data, freqmin, freqmax, df, corners=4, zerophase=True, axis=-1):
"""
Butterworth-Bandpass Filter.
Filter data, with time progressing down the rows, from freqmin to freqmax using
corners corners.
:param data: Data to filter, type numpy.ndarray.
:param freqmin: Pass band low corner frequency.
:param freqmax: Pass band high corner frequency.
:param df: Sampling rate in Hz.
:param corners: Filter corners. Note: This is twice the value of PITSA's
filter sections
:param zerophase: If True, apply filter once forwards and once backwards.
This results in twice the number of corners but zero phase shift in
the resulting filtered trace.
:return: Filtered data.
From http://obspy.org
"""
fe = 0.5 * df
low = freqmin / fe
high = freqmax / fe
# raise for some bad scenarios
if high > 1:
high = 1.0
msg = "Selected high corner frequency is above Nyquist. " + \
"Setting Nyquist as high corner."
import warnings
warnings.warn(msg)
if low > 1:
msg = "Selected low corner frequency is above Nyquist."
raise ValueError(msg)
[b, a] = sig.iirfilter(corners, [low, high], btype='band',
ftype='butter', output='ba')
filtered = sig.lfilter(b, a, data, axis=axis)
if zerophase:
axisReversed = [slice(None),] * filtered.ndim
axisReversed[axis] = slice(None,None,-1)
filtered = sig.lfilter(b,a,filtered[axisReversed])[axisReversed]
return filtered
def notch_filter(band,
cutoff,
ripple,
rs,
sr=internal_sr,
order=2,
filter_type='cheby2'):
#creates chebyshev polynomials for a notch filter with given parameters
nyq = sr / 2.0
low = cutoff - band / 2.0
high = cutoff + band / 2.0
low = low / nyq
high = high / nyq
w0 = cutoff / (sr / 2)
a, b = iirfilter(order, [low, high],
rp=ripple,
rs=rs,
btype='bandstop',
analog=False,
ftype=filter_type)
return a, b
def baseline_plot(x):
all_axes = plt.subplots(3, 2)[1]
for ri, (axes, freq) in enumerate(zip(all_axes, [0.1, 0.3, 0.5])):
for ci, ax in enumerate(axes):
if ci == 0:
iir_hp = signal.iirfilter(4, freq / sfreq, btype='highpass',
output='sos')
x_hp = sosfiltfilt(iir_hp, x, padlen=0)
else:
x_hp -= x_hp[t < 0].mean()
ax.plot(t, x, color='0.5')
ax.plot(t, x_hp, color='k', linestyle='--')
if ri == 0:
ax.set(title=('No ' if ci == 0 else '') +
'Baseline Correction')
ax.set(xticks=tticks, ylim=ylim, xlim=xlim, xlabel=xlabel)
ax.set_ylabel('%0.1f Hz' % freq, rotation=0,
horizontalalignment='right')
mne.viz.adjust_axes(axes)
mne.viz.tight_layout()
plt.suptitle(title)
plt.show()
def process_file(filename,
filter_params=0.1,
p_w=(355, 530),
cutoff=32600,
nchannels=1,
f_type='lowpass',
**args):
#reads each event, filters it and return filtered minima
#p_w: peak window
#cutoff: geatest pretrigger min value
b, a = iirfilter(1, filter_params, btype=f_type, **args)
my_dtype = return_dtype(nchannels)
with open(filename, 'rb') as f:
fil_min = [
min(fevent[p_w[0]:p_w[1]])
for fevent in (filtfilt(b, a,
np.fromstring(event, my_dtype)[0][5])
for event in event_generator(f, nchannels))
if min(fevent[:p_w[0]]) > cutoff and max(fevent[:10]) < 350
]
return fil_min
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
- 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
#Bandpass filter
b_bandpass, a_bandpass = butter(bp_order, [self.low, self.high],
btype='band')
self.bp_filtered_eeg_data = lfilter(b_bandpass, a_bandpass,
self.raw_eeg_data)
self.notch_filtered_eeg_data = self.bp_filtered_eeg_data
self.low1 = notch_freq_Hz[0]
self.high1 = notch_freq_Hz[1]
self.low1 = self.low1 / self.nyq
self.high1 = self.high1 / self.nyq
b_notch, a_notch = iirfilter(2, [self.low1, self.high1],
btype='bandstop')
self.notch_filtered_eeg_data = lfilter(b_notch, a_notch,
self.notch_filtered_eeg_data)
def lowpass(data, freq, df, corners=4, zerophase=False):
"""
Butterworth-Lowpass Filter.
Filter data removing data over certain frequency ``freq`` using ``corners``
corners.
The filter uses :func:`scipy.signal.iirfilter` (for design)
and :func:`scipy.signal.sosfilt` (for applying the filter).
:type data: numpy.ndarray
:param data: Data to filter.
:param freq: Filter corner frequency.
:param df: Sampling rate in Hz.
:param corners: Filter corners / order.
:param zerophase: If True, apply filter once forwards and once backwards.
This results in twice the number of corners but zero phase shift in
the resulting filtered trace.
:return: Filtered data.
"""
fe = 0.5 * df
f = freq / fe
# raise for some bad scenarios
if f > 1:
f = 1.0
msg = "Selected corner frequency is above Nyquist. " + \
"Setting Nyquist as high corner."
warnings.warn(msg)
z, p, k = iirfilter(corners,
f,
btype='lowpass',
ftype='butter',
output='zpk')
sos = zpk2sos(z, p, k)
if zerophase:
firstpass = sosfilt(sos, data)
return sosfilt(sos, firstpass[::-1])[::-1]
else:
return sosfilt(sos, data)
def notchFilterData(
data: Dict[str, np.ndarray], sampleFreq: float, notch: float, band: float
) -> Dict[str, np.ndarray]:
"""Notch filter array data
Parameters
----------
data : Dict
Dictionary with channel as keys and data as values
sampleFreq : float
Sampling frequency in Hz
notch : float
Frequency to notch in Hz
band : float
The bandwidth around the centerline freqency that you wish to filter
Returns
-------
data : Dict
Dictionary with channel as keys and data as values
"""
# set parameters
nyq = sampleFreq / 2.0
low = notch - band / 2.0
high = notch + band / 2.0
low = low / nyq
high = high / nyq
# filter
order = 2
filter_type = "bessel"
filteredData = {}
for c in data:
b, a = signal.iirfilter(
order, [low, high], btype="bandstop", analog=False, ftype=filter_type
)
filteredData[c] = signal.lfilter(b, a, data[c])
return filteredData
def Implement_Notch_Filter(fs, band, freq, ripple, order, filter_type, data):
# Required input defintions are as follows;
# fs: sampling rate
# band: The bandwidth around the centerline freqency that you wish to filter
# freq: The centerline frequency to be filtered
# ripple: The maximum passband ripple that is allowed in db
# order: The filter order. For FIR notch filters this is best set to 2 or 3,
# IIR filters are best suited for high values of order. This algorithm
# is hard coded to FIR filters
# filter_type: 'butter', 'bessel', 'cheby1', 'cheby2', 'ellip'
# data: the data to be filtered
nyq = fs / 2.0
low = freq - band / 2.0
high = freq + band / 2.0
low = low / nyq
high = high / nyq
b, a = signal.iirfilter(order, [low, high],
rp=ripple,
btype='bandstop',
analog=False,
ftype=filter_type)
filtered_data = signal.lfilter(b, a, data)
return filtered_data
def bandpass(data, sampling_rate, freqmin, freqmax, corners=4, zerophase=True):
"""modified after obspy
"""
fe = 0.5 * sampling_rate
low = freqmin / fe
high = freqmax / fe
# raise for some bad scenarios
if high - 1.0 > -1e-6:
msg = ("Selected high corner frequency ({}) of bandpass is at or "
"above Nyquist ({})").format(
freqmax, fe)
raise ValueError(msg)
if low > 1:
msg = "Selected low corner frequency is above Nyquist."
raise ValueError(msg)
z, p, k = iirfilter(corners, [low, high], btype='band',
ftype='butter', output='zpk')
sos = zpk2sos(z, p, k)
if zerophase:
firstpass = sosfilt(sos, data)
return sosfilt(sos, firstpass[::-1])[::-1]
else:
return sosfilt(sos, data)
def iirFilter(self,
order,
criticalFrequencies,
filterClass,
filterType="lowpass",
rippleStopBand=60,
ripplePassBand=1):
"""
Filterclasses:
- butter
- cheby1
- cheby2
- ellip
- bessel
"""
self.b, self.a = signal.iirfilter(order,
criticalFrequencies,
btype=filterType,
analog=True,
rp=ripplePassBand,
rs=rippleStopBand,
ftype=filterClass)
self.fixNumeratorDenominator()
def filter_signal(self, x, low, high):
"""bandpass filtering to input data.
Parameters
----------
x : {array-like, sample × index}.
data to filtering.
low : int
cuttoff frequency along low side
high : int
cuttoff frequency along high side
Returns
----------
x: filtered signals :numpy-array
"""
## set filtering parameters
low = low / (self.srate / 2.)
high = high / (self.srate / 2.)
b_filt, a_filt = signal.iirfilter(self.filter_order, [low, high],
btype='band')
return signal.filtfilt(b_filt, a_filt, x, axis=0)
def __iir_filtering(pulse, right_echo, left_echo, fs):
"""
calc iir filter
"""
max_freq = 100e3
min_freq = 20e3
min_T = 1 / max_freq
max_T = 1 / min_freq
bin_num = 81
dT = (max_T - min_T) / bin_num
bandwidth = 4e3
f_emit_list = []
f_echo_right_list = []
f_echo_left_list = []
for i in range(bin_num):
if i == 0:
hz = 0
else:
hz = 1 / i*dT
sos = signal.iirfilter(N=10,
Wn=[min_freq + hz - bandwidth / 2,
min_freq + hz + bandwidth / 2],
btype="bandpass",
analog=False,
ftype="butter",
output="sos",
fs=fs)
f_emit_wave = signal.sosfiltfilt(sos, pulse, padlen=0)
f_echo_wave_right = signal.sosfiltfilt(
sos, right_echo)
f_echo_wave_left = signal.sosfiltfilt(
sos, left_echo)
f_emit_list.append(f_emit_wave)
f_echo_right_list.append(f_echo_wave_right)
f_echo_left_list.append(f_echo_wave_left)
return f_emit_list, f_echo_right_list, f_echo_left_list
def __init__(self, fp, fs, gpass, gstop, ftype, btype):
#Variables init.
self.fp = fp
self.fs = fs
self.gpass = gpass
self.gstop = gstop
self.ftype = ftype
self.btype = btype
#Filter type for plot's title.
types_dict = {
"butter": "Butterworth",
"cheby1": "Chebyshev I",
"cheby2": "Chebyshev II",
"ellip": "Cauer"
}
self.ftype_plot = types_dict[ftype]
self.__wsk()
self.__filter_order()
#Designing filter.
(self.b, self.a) = signal.iirfilter(self.ord,
self.wn,
rp=self.gpass,
rs=self.gstop,
btype=self.btype,
analog=True,
output='ba',
ftype=ftype)
#Frequency response of analog filter.
(self.w, self.h) = signal.freqs(self.b, self.a, worN=1000)
#Denormalizing variabels for ploting. Pulsation to frequency.
self.w = (self.w * (self.sampling_w / 2)) / (2 * pi)
self.wn = (self.wn * (self.sampling_w / 2)) / (2 * pi)
