def nc_afsk1200Demod(sig, fs=48000.0, TBW=2.0):
# non-coherent demodulation of afsk1200
# function returns the NRZ (without rectifying it)
#
# sig - signal
# baud - The bitrate. Default 1200
# fs - sampling rate in Hz
# TBW - TBW product of the filters
#
# Returns:
# NRZ
# your code here
taps = fs/1200-1
bandpass = signal.firwin(taps, 1200, nyq=fs/2)
spacepass = bandpass * np.exp(1j*2*np.pi*1200*np.r_[0.0:taps]/fs)
markpass = bandpass * np.exp(1j*2*np.pi*3600*np.r_[0.0:taps]/fs)
spaces = signal.fftconvolve(sig, spacepass, mode='same')
marks = signal.fftconvolve(sig, markpass, mode='same')
analog = np.abs(spaces)-np.abs(marks)
lowpass = signal.firwin(taps, 2400*1.2, nyq=fs/2)
filtered = signal.fftconvolve(analog, lowpass, mode='same')
NRZ = filtered
return NRZ
def fm_afskDemod(sig, TBW=4, N=74, fs=48000.0):
#TODO: add docstring
# non-coherent demodulation of afsk1200
# function returns the NRZI (without rectifying it)
baud = 1200.0
bandwidth = 2*500.0 + baud
#TODO fix this
M = int(2/(bandwidth/fs))
h = signal.firwin(74.0, bandwidth, nyq=fs/2)
t = r_[0.0:len(h)]/fs
fc = 1700.0
h = h*np.exp(1j*2*np.pi*fc*t)
output = signal.fftconvolve(h, sig)
temp = output*np.conjugate(np.roll(output, 1))
NRZ_fm = np.angle(temp)/3
h2 = signal.firwin(74.0, 1200, nyq=fs/2)
NRZ_fm = signal.fftconvolve(NRZ_fm, h2)
NRZ_fm = (NRZ_fm*fs/(2.0*np.pi)-550.0)/500.0
return NRZ_fm
def test_scaling(self):
"""
For one lowpass, bandpass, and highpass example filter, this test
checks two things:
- the mean squared error over the frequency domain of the unscaled
filter is smaller than the scaled filter (true for rectangular
window)
- the response of the scaled filter is exactly unity at the center
of the first passband
"""
N = 11
cases = [
([.5], True, (0, 1)),
([0.2, .6], False, (.4, 1)),
([.5], False, (1, 1)),
]
for cutoff, pass_zero, expected_response in cases:
h = firwin(N, cutoff, scale=False, pass_zero=pass_zero, window='ones')
hs = firwin(N, cutoff, scale=True, pass_zero=pass_zero, window='ones')
if len(cutoff) == 1:
if pass_zero:
cutoff = [0] + cutoff
else:
cutoff = cutoff + [1]
assert_(self.mse(h, [cutoff]) < self.mse(hs, [cutoff]),
'least squares violation')
self.check_response(hs, [expected_response], 1e-12)
def demodulate2(self,samples):
# DEMODULATION CODE
# LIMITER goes here
# low pass & down sampling
h = signal.firwin(128,80000,nyq=1.2e5)
lp_samples = signal.fftconvolve(samples, h)
# polar discriminator
A = lp_samples[1:lp_samples.size]
B = lp_samples[0:lp_samples.size-1]
dphase = ( A * np.conj(B) ) / np.pi
dphase.resize(dphase.size+1)
dphase[dphase.size-1] = dphase[dphase.size-2]
h = signal.firwin(128,16000,nyq=1.2e5)
rebuilt = signal.fftconvolve(dphase,h)
output = rebuilt[::self.decim_r2]
output = self.lowpass(output, self.audioFilterSize)
return np.real(output)
def fir_filter(self, fir_ac=None, fir_dc=None, f_ac=None, f_dc=None,
a_ac=10, a_dc=10, alpha=None, filter_name=None, **kwargs):
"""Apply filters to generate the lock-in and dc components of phi"""
if filter_name == 'bessel_matched':
N_pts = kwargs.get('N_pts', int(self.ks / self.k0_dc * 6))
dec = kwargs.get('dec', 32)
n_pts_eval_fir = kwargs.get('n_pts_eval_fir', 2**16)
window = kwargs.get('window', 'hann')
fir_ac, fir_dc = _matched_filters(self.ks, self.x_m, N_pts, dec, window,
n_pts_eval_fir)
self.fir_ac = fir_ac
self.fir_dc = fir_dc
else:
if fir_ac is None:
if f_ac is None and alpha is None:
f_ac = self.fx * 0.5
elif alpha is not None:
f_ac = self.v_tip/self.x_m * alpha
self.fir_ac = signal.firwin(self.fs / (f_ac) * a_ac,
f_ac, nyq=0.5 * self.fs,
window='blackman')
else:
self.fir_ac = fir_ac
if fir_dc is None:
if f_dc is None and alpha is None:
f_dc = self.fx * 0.5
elif alpha is not None:
f_dc = self.v_tip/self.x_m * alpha
self.fir_dc = signal.firwin(self.fs/(f_dc) * a_dc,
f_dc, nyq=0.5*self.fs,
window='blackman')
else:
self.fir_dc = fir_dc
indices = np.arange(self.phi.size)
fir_ac_size = self.fir_ac.size
fir_dc_size = self.fir_dc.size
fir_max_size = max(fir_ac_size, fir_dc_size)
self.m = indices[fir_max_size//2: -fir_max_size//2]
self.tm = self.t[self.m]
self._lock = np.exp(np.pi * 2j * self.fx * self.t)
self.phi_lock = signal.fftconvolve(self.phi * self._lock * 2,
self.fir_ac,
mode='same')
self.V_lock = self.phi_lock
self.phi_lock_a = np.abs(self.phi_lock)
self.phi_lock_phase = np.angle(self.phi_lock)
self.phi_dc = signal.fftconvolve(self.phi, self.fir_dc, mode='same')
self.V_dc = self.phi_dc
def test_fir():
print "Testing dsp-fir"
#ref = ones(512)
ref = (2.0 * random.rand(512)) - 1.0
#test short mono fir
writeaudio(ref)
h = signal.firwin(21, 0.4)
savetxt("test_coeffs.txt", h)
expected = signal.lfilter(h, 1, ref)
writeaudio(expected, 'expected.wav')
os.system("../file-qdsp -n 64 -i test_in.wav -o test_out.wav -p fir,h=test_coeffs.txt")
compareaudio(expected, readaudio(), 1e-6)
#test long mono fir
writeaudio(ref)
h = signal.firwin(312, 0.4)
savetxt("test_coeffs.txt", h)
expected = signal.lfilter(h, 1, ref)
os.system("../file-qdsp -n 64 -i test_in.wav -o test_out.wav -p fir,h=test_coeffs.txt")
compareaudio(expected, readaudio(), 1e-6)
#test short stereo fir, mono coeffs
writeaudio(transpose([ref,-ref]))
h = signal.firwin(21, 0.4)
savetxt("test_coeffs.txt", h)
expected = signal.lfilter(h, 1, ref)
os.system("../file-qdsp -n 64 -i test_in.wav -o test_out.wav -p fir,h=test_coeffs.txt")
compareaudio(transpose([expected, -expected]), readaudio(), 1e-6)
#test long stereo fir, mono coeffs
writeaudio(transpose([ref,-ref]))
h = signal.firwin(312, 0.4)
savetxt("test_coeffs.txt", h)
expected = signal.lfilter(h, 1, ref)
os.system("../file-qdsp -n 64 -i test_in.wav -o test_out.wav -p fir,h=test_coeffs.txt")
compareaudio(transpose([expected, -expected]), readaudio(), 1e-6)
#test asymmetric mono fir
writeaudio(ref)
impulse = concatenate(([1], zeros(499)))
b, a = signal.butter(2, 500.0/24000, 'low')
h = signal.lfilter(b, a, impulse)
savetxt("test_coeffs.txt", h)
expected = signal.lfilter(h, 1, ref)
os.system("../file-qdsp -n 64 -i test_in.wav -o test_out.wav -p fir,h=test_coeffs.txt")
compareaudio(expected, readaudio(), 1e-6)
#test asymmetric stereo fir
writeaudio(transpose([ref,-ref]))
impulse = concatenate(([1], zeros(499)))
b, a = signal.butter(2, 500.0/24000, 'low')
h = signal.lfilter(b, a, impulse)
savetxt("test_coeffs.txt", h)
expected = signal.lfilter(h, 1, ref)
os.system("../file-qdsp -n 64 -i test_in.wav -o test_out.wav -p fir,h=test_coeffs.txt")
compareaudio(transpose([expected, -expected]), readaudio(), 1e-6)
os.remove('test_coeffs.txt')
def designLinearBandpass(fa, fb, s_step, n=1001, show=False):
f_sampling = 1/s_step
nyq = f_sampling / 2
fa_ny = fa / nyq
fb_ny = fb / nyq
a = signal.firwin(n, cutoff = fa_ny, window = 'blackmanharris')
#Highpass filter with spectral inversion
b = - signal.firwin(n, cutoff = fb_ny, window = 'blackmanharris')
# b[n/2] = b[n/2] + 1
#Combine into a bandpass filter
# d = - (a+b); d[n/2] = d[n/2] + 1
b[nyq/2] = b[nyq/2] + 1
#Combine into a bandpass filter
d = - (a+b)
d[nyq/2] = d[nyq/2] + 1
#Frequency response
if show:
mfreqz(d)
pylab.show()
return d
def __init__(self, fs = 48000.0, Abuffer = 1024, Nchunks=43):
# Implementation of an afsk1200 TNC.
#
# The TNC processes a `Abuffer` long buffers, till `Nchunks` number of buffers are collected into a large one.
# This is because python is able to more efficiently process larger buffers than smaller ones.
# Then, the resulting large buffer is demodulated, sampled and packets extracted.
#
# Inputs:
# fs - sampling rate
# TBW - TBW of the demodulator filters
# Abuffer - Input audio buffers from Pyaudio
# Nchunks - Number of audio buffers to collect before processing
# plla - agressivness parameter of the PLL
## compute sizes based on inputs
self.TBW = 2.0 # TBW for the demod filters
self.N = (int(fs/1200*self.TBW)//2)*2+1 # length of the filters for demod
self.fs = fs # sampling rate
self.BW = self.TBW/(1.0*self.N/fs) # BW of filter based on TBW
self.Abuffer = Abuffer # size of audio buffer
self.Nchunks = Nchunks # number of audio buffers to collect
self.Nbuffer = Abuffer*Nchunks+self.N*3-3 # length of the large buffer for processing
self.Ns = 1.0*fs/1200 # samples per symbol
## state variables for the modulator
self.prev_ph = 0 # previous phase to maintain continuous phase when recalling the function
## Generate Filters for the demodulator
self.h_lp = signal.firwin(self.N,self.BW/fs*1.0,window='hanning')
self.h_lpp = signal.firwin(self.N,self.BW*2*1.2/fs,window='hanning')
self.h_space = self.h_lp*exp(1j*2*pi*(2200)*r_[-self.N/2:self.N/2]/fs)
self.h_mark = self.h_lp*exp(1j*2*pi*(1200)*r_[-self.N/2:self.N/2]/fs)
self.h_bp = signal.firwin(self.N,self.BW/fs*2.2,window='hanning')*exp(1j*2*pi*1700*r_[-self.N/2:self.N/2]/fs)
## PLL state variables -- so conntinuity between buffers is preserved
self.dpll = np.round(2.0**32 / self.Ns).astype(int32) # PLL step
self.pll = 0 # PLL counter
self.ppll = -self.dpll # PLL counter previous value -- to detect overflow
self.plla = 0.74 # PLL agressivness (small more agressive)
## state variable to NRZI2NRZ
self.NRZIprevBit = True
## State variables for findPackets
self.state='search' # state variable: 'search' or 'pkt'
self.pktcounter = 0 # counts the length of a packet
self.packet = bitarray.bitarray([0,1,1,1,1,1,1,0]) # current packet being collected
self.bitpointer = 0 # poiter to advance the search beyond what was already searched in the previous buffer
## State variables for processBuffer
self.buff = zeros(self.Nbuffer) # large overlapp-save buffer
self.chunk_count = 0 # chunk counter
self.oldbits = bitarray.bitarray([0,0,0,0,0,0,0]) # bits from end of prev buffer to be copied to beginning of new
self.Npackets = 0 # packet counter
def fir_filt_prep(length, start_ind, stop_ind, numtaps=1000, window="blackmanharris"):
"""preps the FIR filter."""
if start_ind==0:
return firwin(numtaps, stop_ind, pass_zero=True,
nyq=length/2.0,
window=window)
return firwin(numtaps, [start_ind, stop_ind], pass_zero=False,
nyq=length/2.0,
window=window)
def test_response(self):
N = 51
f = .5
# increase length just to try even/odd
h = firwin(N, f) # low-pass from 0 to f
self.check_response(h, [(.25,1), (.75,0)])
h = firwin(N+1, f, window='nuttall') # specific window
self.check_response(h, [(.25,1), (.75,0)])
h = firwin(N+2, f, pass_zero=False) # stop from 0 to f --> high-pass
self.check_response(h, [(.25,0), (.75,1)])
f1, f2, f3, f4 = .2, .4, .6, .8
h = firwin(N+3, [f1, f2], pass_zero=False) # band-pass filter
self.check_response(h, [(.1,0), (.3,1), (.5,0)])
h = firwin(N+4, [f1, f2]) # band-stop filter
self.check_response(h, [(.1,1), (.3,0), (.5,1)])
h = firwin(N+5, [f1, f2, f3, f4], pass_zero=False, scale=False)
self.check_response(h, [(.1,0), (.3,1), (.5,0), (.7,1), (.9,0)])
h = firwin(N+6, [f1, f2, f3, f4]) # multiband filter
self.check_response(h, [(.1,1), (.3,0), (.5,1), (.7,0), (.9,1)])
h = firwin(N+7, 0.1, width=.03) # low-pass
self.check_response(h, [(.05,1), (.75,0)])
h = firwin(N+8, 0.1, pass_zero=False) # high-pass
self.check_response(h, [(.05,0), (.75,1)])
def init(self):
self.count0 = 0
self.count1 = 0
# Open the wav music file
MusicFile = open(self.musicFileName, 'r')
# Read the music samples into an array
self.MusicFileArray = MusicFile.read()
self.MusicFileArray = self.MusicFileArray[:(len(self.MusicFileArray) - 1)]
self.MusicFileArray = self.MusicFileArray.split("\n")
# Filter0
coeffFilter0 = signal.firwin(self.FilterDict["Filter0"]['N'], [self.FilterDict["Filter0"]["fc0"], self.FilterDict["Filter0"]["fc1"]], nyq = (0.5 * self.FilterDict["Filter0"]["fs"]), window = 'hamming')
## Calculate coefficients in C
print "C implementation"
set_trace()
###############
for i in range(len(coeffFilter0)):
coeffFilter0[i] = example.hamming_win(self.FilterDict["Filter0"]['N'], i, self.FilterDict["Filter0"]["fc1"], self.FilterDict["Filter0"]["fs"])
set_trace()
##################
coeffFilter0Fp = []
for i in coeffFilter0:
coeffFilter0Fp.append(int(fp_sign_to_bin(i, self.fpNotation), 2))
self.FilterDict["Filter0"]["Coefficients"] = coeffFilter0Fp
# Filter1
coeffFilter1 = signal.firwin(self.FilterDict["Filter1"]['N'], [self.FilterDict["Filter1"]["fc0"], self.FilterDict["Filter1"]["fc1"]], nyq = (0.5 * self.FilterDict["Filter1"]["fs"]), window = 'hamming')
coeffFilter1Fp = []
for i in coeffFilter1:
coeffFilter1Fp.append(int(fp_sign_to_bin(i, self.fpNotation), 2))
self.FilterDict["Filter1"]["Coefficients"] = coeffFilter1Fp
# Filter2
coeffFilter2 = signal.firwin(self.FilterDict["Filter2"]['N'], [self.FilterDict["Filter2"]["fc0"], self.FilterDict["Filter2"]["fc1"]], nyq = (0.5 * self.FilterDict["Filter2"]["fs"]), window = 'hamming')
coeffFilter2Fp = []
for i in coeffFilter2:
coeffFilter2Fp.append(int(fp_sign_to_bin(i, self.fpNotation), 2))
self.FilterDict["Filter2"]["Coefficients"] = coeffFilter2Fp
# Filter3
coeffFilter3 = signal.firwin(self.FilterDict["Filter3"]['N'], [self.FilterDict["Filter3"]["fc0"], self.FilterDict["Filter3"]["fc1"]], nyq = (0.5 * self.FilterDict["Filter3"]["fs"]), window = 'hamming')
coeffFilter3Fp = []
for i in coeffFilter3:
coeffFilter3Fp.append(int(fp_sign_to_bin(i, self.fpNotation), 2))
self.FilterDict["Filter3"]["Coefficients"] = coeffFilter3Fp
def get_h_parameters(NFIR, fcut):
"""NFIR : length of FIR filter
fcut: fraction of Nyquist for filter"""
h = si.firwin(NFIR+1,fcut) * np.exp(2*1j*np.pi*np.arange(NFIR+1)*0.125)
n = np.arange(2,NFIR+2)
g = h[(1-n)%NFIR]*(-1)**(1-n)
NFIR = np.fix((3./2.*NFIR))
h1 = si.firwin(NFIR+1,2./3*fcut)*np.exp(2j*np.pi*np.arange(NFIR+1)*0.25/3.)
h2 = h1*np.exp(2j*np.pi*np.arange(NFIR+1)/6.)
h3 = h1*np.exp(2j*np.pi*np.arange(NFIR+1)/3.)
return (h, g, h1, h2, h3)
def process(self,samples):
#samples = sdr.read_samples(2.56e6)
h = signal.firwin(256,80000,nyq=1.2e5)
output = signal.fftconvolve(samples,h)
output[:h.size/2] += self.prevConv1[h.size/2:] #add the latter half of tail end of the previous convolution
outputa = np.append(self.prevConv1[:h.size/2], output) # also delayed by half size of h so append the first half
self.prevConv1 = output[output.size-h.size:] # set the tail for next iteration
lp_samples = outputa[:output.size-h.size] # chop off the tail and decimate
#lp_samples = output[::5]
dmod = np.zeros(lp_samples.size)
A = lp_samples[1:]
B = lp_samples[:lp_samples.size-1]
dmod[1:] = np.real(np.angle(A * np.conj(B))) / (np.pi)
dmod[0] = np.real(np.angle(lp_samples[0] * np.conj(self.prevB))) / (np.pi)
self.prevB = lp_samples[lp_samples.size-1]
h = signal.firwin(256,1.6e4,nyq=1.2e5)
output = signal.fftconvolve(dmod,h)
output[:h.size/2] += self.prevConv2[h.size/2:] #add the latter half of tail end of the previous convolution
outputa = np.append(self.prevConv2[:h.size/2], output) # also delayed by half size of h so append the first half
self.prevConv2 = output[output.size-h.size:] # set the tail for next iteration
audible = outputa[:output.size-h.size:5] # chop off the tail and decimate
#h = signal.firwin(128,1.6e4,nyq=24000)
#output = signal.fftconvolve(audible,h)
#output[:h.size/2] += prevConv3[h.size/2:] #add the latter half of tail end of the previous convolution
#outputa = np.append(prevConv3[:h.size/2], output) # also delayed by half size of h so append the first half
#prevConvo3 = output[output.size-h.size:] # set the tail for next iteration
#audible = outputa[:output.size-h.size:5] # chop off the tail and decimate
#print audible.size
#spec = gen_spec(audible,256)
#show_image(spec)
self.spec = np.roll(self.spec,26,axis=1)
self.spec[:,:26] = gen_spec(np.real(audible),512) ##np.abs(np.fft.fft(audible)[:audible.size/2:-4])
spec = cv2.GaussianBlur(self.spec,(5,5),1,.75)
spectsc = cv2.convertScaleAbs(self.spec,alpha=255/np.max(spec))
spect = cv2.applyColorMap(spectsc,cv2.COLORMAP_JET)
cv2.imshow('Spectrum',spect)
cv2.waitKey(1)
return np.real(.5*audible)
def createFilters():
fs = 500
f_nyquist = fs/2 # Calling nyquist fs/2 because this corresponds to pi radians
numtaps = 71 # must be less than sig_length / 3
h_lp_ecg = signal.firwin(numtaps, 150./f_nyquist)
h_lp_icg = signal.firwin(numtaps, 1./f_nyquist)
h_lp_ppg = signal.firwin(numtaps, 30./f_nyquist) # Can be used for ICG - cardiac
h_60 = signal.firwin(numtaps, [55./f_nyquist, 65./f_nyquist])
h_hp = signal.firwin(numtaps, 5./f_nyquist, pass_zero=False)
return(h_lp_ecg, h_lp_icg, h_lp_ppg, h_60, h_hp)
def bandreject(self, S, low=700, high=800):
# http://www.scipy.org/Cookbook/FIRFilter
# http://mpastell.com/2010/01/18/fir-with-scipy/
nyq_rate = self.spl_rate / 2.0
width = 50.0 / nyq_rate
ripple_db = 60.0
N, beta = signal.kaiserord(ripple_db, width)
tapsL = signal.firwin(N, low / nyq_rate, window=("kaiser", beta))
tapsH = signal.firwin(N, high / nyq_rate, window=("kaiser", beta))
tapsB = -(tapsL + tapsH)
tapsB[N / 2] = tapsB[N / 2] + 1
return signal.lfilter(tapsB, 1.0, S)
def nc_mafsk1200Demod(sig, fs=48000.0, baud=1200, TBW=2.0, fc = 2700, fd = 1000):
# non-coherent demodulation of afsk1200
# function returns the NRZ (without rectifying it)
#
# sig - signal
# baud - The bitrate. Default 1200
# fs - sampling rate in Hz
# TBW - TBW product of the filters
#
# Returns:
# NRZ
N = (int(fs/baud*TBW)//2)*2+1
f11 = fc - 2*fd
f10 = fc - fd
f01 = fc + fd
f00 = fc + 2*fd
# your code here
taps = TBW*fs/1200-1
taps = N
filt = signal.firwin(taps, baud/2, window='hanning', nyq=fs/2)
#plt.plot(np.fft.fft(filt))
#plt.plot(filt)
#f1 = 1200
#f2 = 2200
t2 = (r_[0:fs]/fs)[:taps]
filt11 = filt* np.exp(t2*1j*f11*-2*np.pi)
filt10 = filt* np.exp(t2*1j*f10*-2*np.pi)
sig11 = signal.fftconvolve(sig, filt11, mode="same")
sig10 = signal.fftconvolve(sig, filt10, mode="same")
filt01 = filt* np.exp(t2*1j*f01*-2*np.pi)
filt00 = filt* np.exp(t2*1j*f00*-2*np.pi)
sig01 = signal.fftconvolve(sig, filt01, mode="same")
sig00 = signal.fftconvolve(sig, filt00, mode="same")
midsig = 0#(max(sig00)+min(sig00)+max(sig11)+min(sig11))/4
sig11r = sig11 - midsig
sig10r = sig10 - midsig
sig01r = sig01 - midsig
sig00r = sig00 - midsig
return sig11r, sig10r, sig01r, sig00r
diff = np.abs(sig12k)-np.abs(sig22k)
return diff
opt = signal.firwin(taps, baud*1.2, window='hanning', nyq=fs/2)
ana = signal.fftconvolve(diff, opt, mode="same")
#sign = np.sign(ana)
NRZ = ana
return NRZ
def initialize_online_filter(fsample, highpass, lowpass, order, x, axis=-1):
# boxcar, triang, blackman, hamming, hann, bartlett, flattop, parzen, bohman, blackmanharris, nuttall, barthann
filtwin = 'nuttall'
nyquist = fsample / 2.
ndim = len(x.shape)
axis = axis % ndim
if highpass != None:
highpass = highpass/nyquist
if highpass < 0.01:
highpass = None
elif highpass > 0.99:
highpass = None
if lowpass != None:
lowpass = lowpass/nyquist
if lowpass < 0.01:
lowpass = None
elif lowpass > 0.99:
lowpass = None
if not(highpass is None) and not(lowpass is None) and highpass>=lowpass:
# totally blocking all signal
print 'using NULL filter', [highpass, lowpass]
b = np.zeros(window)
a = np.ones(1)
elif not(lowpass is None) and (highpass is None):
print 'using lowpass filter', [highpass, lowpass]
b = firwin(order, cutoff = lowpass, window = filtwin, pass_zero = True)
a = np.ones(1)
elif not(highpass is None) and (lowpass is None):
print 'using highpass filter', [highpass, lowpass]
b = firwin(order, cutoff = highpass, window = filtwin, pass_zero = False)
a = np.ones(1)
elif not(highpass is None) and not(lowpass is None):
print 'using bandpass filter', [highpass, lowpass]
b = firwin(order, cutoff = [highpass, lowpass], window = filtwin, pass_zero = False)
a = np.ones(1)
else:
# no filtering at all
print 'using IDENTITY filter', [highpass, lowpass]
b = np.ones(1)
a = np.ones(1)
# initialize the state for the filtering based on the previous data
if ndim == 1:
zi = zi = lfiltic(b, a, x, x)
elif ndim == 2:
f = lambda x : lfiltic(b, a, x, x)
zi = np.apply_along_axis(f, axis, x)
return b, a, zi
def testfir(st,cb,ct,n):
from scipy import signal
import numpy as np
sr = st[0].stats.sampling_rate/2.
xx = np.empty([st.count(),n],)
a = signal.firwin(n, cutoff = cb/sr, window = 'hamming')
b = - signal.firwin(n, cutoff = ct/sr, window = 'hamming'); b[n/2] = b[n/2] + 1
d = - (a+b); d[n/2] = d[n/2] + 1
fft1 = np.abs(np.fft.fft(d))
for i in range(st.count()):
fft = np.fft.fft(st[i][:n])*fft1
xx[i] = np.fft.ifft(fft)
return xx
def bandpass_filter(signal, signal_rate, lowcut, highcut, window='hann'):
""" Apply bandpass filter. Everything below 'lowcut' and above 'highcut'
frequency level will be greatly reduced. """
ntaps = 199
nyq = 0.5 * signal_rate
lowpass = firwin(ntaps, lowcut, nyq=nyq, pass_zero=False,
window=window, scale=False)
highpass = - firwin(ntaps, highcut, nyq=nyq, pass_zero=False,
window=window, scale=False)
highpass[ntaps/2] = highpass[ntaps/2] + 1
bandpass = -(lowpass + highpass)
bandpass[ntaps/2] = bandpass[ntaps/2] + 1
filteredSignal = lfilter(bandpass, 1.0, signal)
return filteredSignal
def __init__(self, fs = 48000, baud = 2400, fc = 1800):
self.fs = fs
self.fc = fc
self.baud = baud
self.f_mark = self.fc - baud / 4
self.f_space = self.fc + baud / 4
self.delta_f = (self.f_space - self.f_mark) / 2
self.spb = self.fs / baud
taps = 2 * int(fs * 2 / baud) + 1
h = signal.firwin(taps, self.baud / 2., nyq = fs / 2., window = 'hanning')
self.bp_mark = np.exp(2j * np.pi * self.f_mark * np.r_[0:taps] / float(fs)) * h
self.bp_space = np.exp(2j * np.pi * self.f_space * np.r_[0:taps] / float(fs)) * h
self.h_nrz = signal.firwin(taps, self.baud * 1.2, nyq = fs / 2., window = 'hanning')
def bandpass(data, sampling, fmin, fmax, ripple_db=50, width=2.0,\
return_filter=False, verbose=False):
"""
This function will bandpass filter data in the given [fmin,fmax] band
using a kaiser window.
Arguments:
data : numpy.ndarray
array of data points
sampling : int
number of data points per second
fmin : float
frequency of lowpass
fmax : float
frequency of highpass
Keyword arguments:
ripple_db : int
Attenuation in the stop band, in dB
width : float
Desired width of the transition from pass to stop, in Hz
return_filter: boolean
Return filter
verbose : boolean
"""
# construct filter
order, beta = signal.kaiserord(ripple_db, width*2/sampling)
lowpass = signal.firwin(order, fmin*2/sampling, window=('kaiser', beta))
highpass = - signal.firwin(order, fmax*2/sampling, window=('kaiser', beta))
highpass[order//2] = highpass[order//2] + 1
bandpass = -(lowpass + highpass); bandpass[order//2] = bandpass[order//2] + 1
# filter data forward then backward
data = signal.lfilter(bandpass,1.0,data)
data = data[::-1]
data = signal.lfilter(bandpass,1.0,data)
data = data[::-1]
if verbose: sys.stdout.write("Bandpass filter applied to data.\n")
if return_filter:
return data, bandpass
else:
return data
def fir(self):
"""
Filter the time-series using an FIR digital filter. Filtering is done
back and forth (using scipy.signal.filtfilt) to achieve zero phase
delay
"""
# Passband and stop-band are expressed as fraction of the Nyquist
# frequency:
if self.ub is not None:
ub_frac = self.ub / (self.sampling_rate / 2.0)
else:
ub_frac = 1.0
lb_frac = self.lb / (self.sampling_rate / 2.0)
if lb_frac < 0 or ub_frac > 1:
e_s = "The lower-bound or upper bound used to filter"
e_s += " are beyond the range 0-Nyquist. You asked for"
e_s += " a filter between"
e_s += "%s and %s percent of" % (lb_frac * 100, ub_frac * 100)
e_s += "the Nyquist frequency"
raise ValueError(e_s)
n_taps = self._filt_order + 1
# This means the filter order you chose was too large (needs to be
# shorter than a 1/3 of your time-series )
if n_taps > self.data.shape[-1] * 3:
e_s = "The filter order chosen is too large for this time-series"
raise ValueError(e_s)
# a is always 1:
a = [1]
sig = ts.TimeSeries(data=self.data, sampling_rate=self.sampling_rate)
# Lowpass:
if ub_frac < 1:
b = signal.firwin(n_taps, ub_frac, window=self._win)
sig = self.filtfilt(b, a, sig)
# High-pass
if lb_frac > 0:
# Includes a spectral inversion:
b = -1 * signal.firwin(n_taps, lb_frac, window=self._win)
b[n_taps / 2] = b[n_taps / 2] + 1
sig = self.filtfilt(b, a, sig)
return sig
def nc_afsk_demod(sig, f_low, f_high, TBW=2.0, N=74, fs = 44100.0):
# non-coherent demodulation of afsk1200
# function returns the NRZI (without rectifying it)
BW = float(TBW) / N
h_mark = signal.firwin(numtaps=N, cutoff=BW) * np.exp(1j * 2 * pi * f_low/fs * np.arange(N))
h_space = signal.firwin(numtaps=N, cutoff=BW) * np.exp(1j * 2 * pi * f_high/fs * np.arange(N))
v_space = signal.fftconvolve(sig, h_space)
v_mark = signal.fftconvolve(sig, h_mark)
NRZa = abs(v_space) - abs(v_mark)
return NRZa[N/2:-N/2]
def demodulateQAM16(signal, fc, fs, symbol_length, predelay):
symbol_size = fs*symbol_length
num_symbols = signal.size // symbol_size
n_taps = 640*2
inphase = np.zeros_like(signal)
quadphase = np.zeros_like(signal)
h = sp.firwin(n_taps, fs/320, nyq=fs/2) # perhaps try using a notch filter instead of a firwin
h *= np.cos(2*np.pi*fc/fs*np.r_[:h.size]) # since the bandwidth of a QAM channel is so small.
#signal = sp.lfilter(h, 1.0, signal)
signal = sp.fftconvolve(signal, h, mode='same')
#spectrum(signal)
#spectrogram(signal)
#myplot(signal)
# calculate phase adjustment:
# using -2 instead of -1 beacuse something weird happens when adding to the np.r_[] below
delay = 0.5*(n_taps-2)
# demodulation to baseband
inphase = signal * np.cos(2*np.pi*fc/fs*(np.r_[:signal.size] + delay + predelay))
quadphase = - signal * np.sin(2*np.pi*fc/fs*(np.r_[:signal.size] + delay + predelay))
#lowpass after demodulating
h = sp.firwin(n_taps/8, fs/160, nyq=fs/2)
inphase = sp.lfilter(h, 1.0, inphase)
quadphase = sp.lfilter(h, 1.0, quadphase)
#inphase = sp.fftconvolve(inphase, h, mode = 'same')
#quadphase = sp.fftconvolve(quadphase, h, mode='same')
#myplot(inphase)
#spectrogram(inphase)
# inphase = sp.medfilt(inphase, int(symbol_size/4)-1)
# quadphase = sp.medfilt(quadphase, int(symbol_size/4)-1)
#myplot(inphase)
#spectrogram(inphase)
# calc delay:
delay = 0.5 * (n_taps/8 -1)
i_coef = inphase[symbol_size/2+delay::symbol_size]
q_coef = quadphase[symbol_size/2+delay::symbol_size]
return matchCode16(i_coef, q_coef)
def __init__(self,hfoObj):
#signal = sig.detrend(hfoObj.waveform[hfoObj.start_idx:hfoObj.end_idx,0]) # detrending
fs = hfoObj.sample_rate
signal = sig.detrend(hfoObj.waveform[3*fs/4:5*fs/4,0])
PhaseFreqVector= np.arange(1,31,1)
AmpFreqVector= np.arange(30,990,5)
PhaseFreq_BandWidth=1
AmpFreq_BandWidth=10
Comodulogram=np.zeros((PhaseFreqVector.shape[0],AmpFreqVector.shape[0]))
nbin=18
position=np.zeros(nbin)
winsize = 2*np.pi/nbin
for j in range(nbin):
position[j] = -np.pi+j*winsize;
PHASES = np.zeros((PhaseFreqVector.shape[0],signal.shape[0]))
for idx,Pf1 in enumerate(PhaseFreqVector):
print Pf1,
Pf2 = Pf1 + PhaseFreq_BandWidth
if signal.shape[0] > 18*np.fix(fs/Pf1):
b = sig.firwin(3*np.fix(fs/Pf1),[Pf1,Pf2],pass_zero=False,window=('kaiser',0.5),nyq=fs/2)
else:
b = sig.firwin(signal.shape[0]/6,[Pf1,Pf2],pass_zero=False,window=('kaiser',0.5),nyq=fs/2)
PhaseFreq = sig.filtfilt(b,np.array([1]),signal)
Phase=np.angle(sig.hilbert(PhaseFreq))
PHASES[idx,:]=Phase;
print
for idx1,Af1 in enumerate(AmpFreqVector):
print Af1,
Af2 = Af1 + AmpFreq_BandWidth
if signal.shape[0] > 18*np.fix(fs/Af1):
b = sig.firwin(3*np.fix(fs/Af1),[Af1,Af2],pass_zero=False,window=('kaiser',0.5),nyq=fs/2)
else:
b = sig.firwin(np.fix(signal.shape[0]/6),[Af1,Af2],pass_zero=False,window=('kaiser',0.5),nyq=fs/2)
AmpFreq = sig.filtfilt(b,np.array([1]),signal)
Amp=np.abs(sig.hilbert(AmpFreq))
for idx2,Pf1 in enumerate(PhaseFreqVector):
Phase = PHASES[idx2]
MeanAmp = np.zeros(nbin)
for j in range(nbin):
bol1 = Phase < position[j]+winsize
bol2 = Phase >= position[j]
I = np.nonzero(bol1 & bol2)[0]
MeanAmp[j]=np.mean(Amp[I])
#MI=(np.log(nbin)-(-np.sum((MeanAmp/np.sum(MeanAmp))*np.log((MeanAmp/np.sum(MeanAmp))))))/np.log(nbin)
MI =np.log(nbin)-(stat.entropy(MeanAmp)/np.log(nbin))
Comodulogram[idx2,idx1]=MI;
plt.contourf(PhaseFreqVector+PhaseFreq_BandWidth/2,AmpFreqVector+AmpFreq_BandWidth/2,Comodulogram.T,100)
def demodulate(sdr_samples, sample_rate, ignore=0):
t = np.arange(len(sdr_samples)) / sample_rate
demod = np.exp(-2j*pi*freq_offset*t)
y = sdr_samples * demod
threshold = 0.04
y = y[abs(y) > threshold]
from scipy import signal #should be imported already?
sig = angle(y[1:] * conj(y[:-1]))
h = signal.firwin(256,5000.0,nyq=sample_rate/2.0)
sigf = signal.fftconvolve(sig, h)
if ignore > 0:
sigf = sigf[ignore:-ignore]
downsample = 24
sigfd = sigf[::downsample]
fs_down = fs
sigfdd = signal.resample(sigfd, len(sigfd) * float(fs_down) / (sample_rate / float(downsample)))
return sigfdd
def highpass(CutOffFreq, SamplingRate, StopGain, TranWidth):
NiquistRate = SamplingRate/2.0
N, beta = sig.kaiserord(StopGain,TranWidth/NiquistRate)
print 'the order of the FIR filter is:' + str(N) + ', If this is bigger than the size of the data please adjust the width and gain of the filter'
taps = sig.firwin(N, CutOffFreq, window=('kaiser', beta), pass_zero=False, scale=True, nyq=NiquistRate)
return taps
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 lowpass(sig):
sample_rate=200
# The Nyquist rate of the signal.
nyq_rate = sample_rate / 2.0
# The desired width of the transition from pass to stop,
# relative to the Nyquist rate. We'll design the filter
# with a 10 Hz transition width.
width = 5.0/nyq_rate
# The desired attenuation in the stop band, in dB.
ripple_db = 10.0
# Compute the order and Kaiser parameter for the FIR filter.
N, beta = kaiserord(ripple_db, width)
#print "N is " , N
# The cutoff frequency of the filter.
cutoff_hz = 15
# Use firwin with a Kaiser window to create a lowpass FIR filter.
taps = firwin(N, cutoff_hz/nyq_rate, window=('kaiser', beta))
# Use lfilter to filter x with the FIR filter.
#print taps
delay = 0.5 * (N-1) / sample_rate
print "Phase delay is " , delay
return lfilter(taps, 1.0, sig)
def LPmin(self, fil_dict):
self.get_params(fil_dict)
(self.N, F, A, W) = pyfda_lib.remezord([self.F_PB, self.F_SB], [1, 0],
[self.A_PB, self.A_SB], Hz = 1, alg = self.alg)
fil_dict['F_C'] = (self.F_SB + self.F_PB)/2 # use average of calculated F_PB and F_SB
self.save(fil_dict, sig.firwin(self.N, fil_dict['F_C'],
window = self.firWindow, nyq = 0.5))
def test_firwin(num_samps, f1, f2):
cpu_window = signal.firwin(num_samps, [f1, f2], pass_zero=False)
gpu_window = cp.asnumpy(
cusignal.firwin(num_samps, [f1, f2], pass_zero=False)
)
assert array_equal(cpu_window, gpu_window)
def __init__(self, Fsample = 8000, Fcutt = 1000, Width = 400, \
Ripple = 60.0):
nyq_rate = Fsample / 2.0
width = Width / nyq_rate
N, beta = kaiserord(Ripple, width)
self.taps = firwin(N, Fcutt / nyq_rate, window=('kaiser', beta))
import scipy.signal as signal
from scipy.fftpack import fft
filter = [0] * ch_number
tap_number = 61
nyquist_freq = sampling_freq * 0.5
"""
N = extraction_freq
dt = 1 / sampling_freq * 2
freq = np.linspace(0, 1.0/dt, N) # frequency step
yf_1 = fft(data_x[0][0])/(N/2)
"""
#"""
#50Hzノッチフィルター
print("50Hz notch filter")
filter = signal.firwin(numtaps=tap_number, cutoff=[49, 51], fs=sampling_freq)
data_x[0:3, :all_sample_number] = signal.lfilter(
filter, 1, data_x[0:3, :all_sample_number])
"""
yf_2 = fft(data_x[0][0])/(N/2)
plt.plot(freq,np.abs(yf_1))
plt.show()
plt.plot(freq,np.abs(yf_2))
plt.show()
"""
#"""
#カットオフ周波数0.5Hzのハイパスフィルター
print("High-pass filter with a cutoff frequency of 0.5Hz")
filter = signal.firwin(numtaps=tap_number, cutoff=0.5, fs=sampling_freq)
data_x[0:3, :all_sample_number] = signal.lfilter(
def highpass(mono, samplerate):
b = sg.firwin(101, cutoff=1000, fs=samplerate, pass_zero=False)
filtered = sg.lfilter(b, [1.0], mono)
return filtered
plt.subplot(212)
plt.plot(signal2)
plt.xlim([0, 400])
plt.ylabel("Signal 2")
plt.show()
# PLOT FOURIER TRANSFORMS ----------------------------
ECG = signal2
fs = 120
ECG = ECG - np.mean(ECG) # Remove DC component
plotfft(ECG, fs)
# FILTER ---------------------------------------------
h = sig.firwin(101, [5, 40], width=None, window='hamming', pass_zero=False, scale=True, fs=fs)
mfreqz(h,1,fs) # bode plot
ECG_filtered = sig.fftconvolve(h, ECG)
# before and after filtering
plt.figure()
plotfft(ECG, fs)
plotfft(ECG_filtered, fs)
plt.legend(['Original','Filtered'])
plt.show()
plt.figure()
plt.subplot(211)
from scipy.signal import fftconvolve, lfilter, firwin
def conj(c):
con = c.real - 1j * c.imag
return con
Fs = 100.0
Ts = 1 / Fs
fc = 20
fd = 25.0
kf = fd / Fs
#Create a FIR filter
b = firwin(2, 0.99, width=0.05, pass_zero=True)
# error en el oscilador del demodulador
demod_fc_error = 0.0
def ind(t):
return int(round(t * Fs))
time = range(0, int((0.5 - Ts) * Fs), int(round(Ts * Fs)))
TestFreq = 4.0
prev_csum = 0
prev_y = 0 + 0j
msg = [0] * len(time)
v = [0] * len(time)
def __init__(self, filterorder=10, cutoff=0.5):
self.filter = sig.firwin(filterorder, cutoff)
import scipy.signal as sig
from scipy.fftpack import fft, fftshift
from spectrum import CORRELOGRAMPSD
from spectrum.tools import cshift
import scipy.io as sio
def mfreqz(b,a=1):
w,h = sig.freqz(b,a)
h_dB = 20 * np.log10 (abs(h))
plt.subplot(211)
plt.plot(w/max(w),h_dB)
plt.ylim(-150, 5)
plt.ylabel('Magnitude (db)')
plt.xlabel(r'Normalized Frequency (x$\pi$rad/sample)')
plt.title(r'Frequency response')
plt.subplot(212)
h_Phase = np.unwrap(np.arctan2(np.imag(h),np.real(h)))
plt.plot(w/max(w),h_Phase)
plt.ylabel('Phase (radians)')
plt.xlabel(r'Normalized Frequency (x$\pi$rad/sample)')
plt.title(r'Phase response')
plt.subplots_adjust(hspace=0.5)
fs = 1000 # Hz
nyq_frec = fs/2
n=500
d = sig.firwin(n, cutoff=[0.3, 0.5], window='blackmanharris', pass_zero=False)
mfreqz(d)
plt.show()
def kaiser_LP_filter(traces, fs, cutoff, width, attenuation):
numtaps, beta = signal.kaiserord(attenuation, width / (0.5 * fs))
taps = signal.firwin(numtaps, cutoff / (0.5 * fs), window=('kaiser', beta))
traces_filtered = signal.lfilter(taps, [1.0], traces)
return traces_filtered
def AddLpFilter(config_lines,
name,
input,
rate,
num_lpfilter_taps,
lpfilt_filename,
is_updatable=False):
try:
import scipy.signal as signal
import numpy as np
except ImportError:
raise Exception(
" This recipe cannot be run without scipy."
" You can install it using the command \n"
" pip install scipy\n"
" If you do not have admin access on the machine you are"
" trying to run this recipe, you can try using"
" virtualenv")
# low-pass smoothing of input was specified. so we will add a low-pass filtering layer
lp_filter = signal.firwin(num_lpfilter_taps,
rate,
width=None,
window='hamming',
pass_zero=True,
scale=True,
nyq=1.0)
lp_filter = list(np.append(lp_filter, 0))
nnet3_train_lib.WriteKaldiMatrix(lpfilt_filename, [lp_filter])
filter_context = int((num_lpfilter_taps - 1) / 2)
filter_input_splice_indexes = range(-1 * filter_context,
filter_context + 1)
list = [('Offset({0}, {1})'.format(input['descriptor'], n)
if n != 0 else input['descriptor'])
for n in filter_input_splice_indexes]
filter_input_descriptor = 'Append({0})'.format(' , '.join(list))
filter_input_descriptor = {
'descriptor': filter_input_descriptor,
'dimension': len(filter_input_splice_indexes) * input['dimension']
}
input_x_dim = len(filter_input_splice_indexes)
input_y_dim = input['dimension']
input_z_dim = 1
filt_x_dim = len(filter_input_splice_indexes)
filt_y_dim = 1
filt_x_step = 1
filt_y_step = 1
input_vectorization = 'zyx'
tdnn_input_descriptor = nodes.AddConvolutionLayer(
config_lines,
name,
filter_input_descriptor,
input_x_dim,
input_y_dim,
input_z_dim,
filt_x_dim,
filt_y_dim,
filt_x_step,
filt_y_step,
1,
input_vectorization,
filter_bias_file=lpfilt_filename,
is_updatable=is_updatable)
return [tdnn_input_descriptor, filter_context, filter_context]
def MdPF_calc(Myo_Frames, Midi_Frames):
MdPF_Frames = []
rate = 1000 #sampling rate
nyq = rate / 2 #ナイキスト周波数
i = 1
while i <= len(Midi_Frames) - 1:
start_point = Midi_Frames[i - 1][0] - Midi_Frames[0][0]
end_point = Midi_Frames[i][0] - Midi_Frames[0][0]
#high pass fir
fe = 20.0 / nyq #[Hz]
numtaps = 255 #フィルタ係数（タップの数（要奇数））
co = spsig.firwin(numtaps, fe, pass_zero=False) #setting coefficient
high_pass_sig = spsig.lfilter(co, 1, Myo_Frames[start_point:end_point])
power_spectrum = do_fft(high_pass_sig)
freqList = fftfreq(high_pass_sig.size, d=1.0 / rate) #周波数の分解能計算
# --- 表示周波数帯制限 ---
#low cut
List_count_low = 0
for row in freqList:
if (row > 20) or (row < 0): #20Hz以上
List_count_low -= 1
break
List_count_low += 1
#high cut
List_count_high = 0
for row in freqList:
if (row > 500) or (row < 0): #500Hz以下
List_count_high -= 1
break
List_count_high += 1
spectrum_sum = np.sum(power_spectrum[List_count_low:List_count_high])
find_mid = 0
index = List_count_low
while find_mid < spectrum_sum / 2:
find_mid += power_spectrum[index]
index += 1
low_mid_f = index - 1
MdPF_Frames.append(freqList[low_mid_f])
"""
find_mid = 0
index = List_count_high
while find_mid < spectrum_sum / 2:
find_mid += power_spectrum[index]
index -= 1
hi_mid_f = index + 1
MdPF_Frames.append((freqList[low_mid_f] + freqList[hi_mid_f]) / 2)
"""
i += 1
return MdPF_Frames
#example taken from scipy documentation
from scipy import signal
import matplotlib.pyplot as plt
import numpy as np
#disenar el filtro usando una ventana kaiser
b = signal.firwin(32, 0.5, window='hamming', pass_zero=True)
#pasa bajas pass_zero=True
#pasa altas pass_zero=False
fs = 1e3
t, T = np.linspace(1. / fs, 5, fs * 5, retstep=True)
nFs = 1 / T
F = 10 #frecuencia fundamental 10 hz
w = 2 * np.pi * 5 #frecuencia angular
Vm = 4 #valor de amplitud de la onda
#generar onda compuesta de sinusoides
y = Vm * np.cos(
w * t) + Vm / 2 * np.cos(2 * w * t + np.deg2rad(45)) + Vm / 3 * np.cos(
3 * w * t) + Vm / 2 * np.cos(4 * w * t)
#generar onda de ruido sinusoidal, alta frecuencia y baja amplitud
x = 2 * np.cos(2 * np.pi * 370 * t)
#onda con ruido
yx = y + x
#filtrar la onda con ruido usando el filtro FIR
yf = signal.lfilter(b, [1.0], yx)
plt.subplot(311)
nyq_rate = sample_rate / 2.0
# The desired width of the transition from pass to stop,
# relative to the Nyquist rate. We'll design the filter
# with a 4 Hz transition width.
width = 4.0 / nyq_rate
# The desired attenuation in the stop band, in dB.
ripple_db = 60.0
# Compute the order and Kaiser parameter for the FIR filter.
N, beta = kaiserord(ripple_db, width)
# The cutoff frequency of the filter.
cutoff_hz = 10.0
# Use firwin with a Kaiser window to create a lowpass FIR filter.
taps = firwin(N, cutoff_hz / nyq_rate, window=('kaiser', beta))
# Use lfilter to filter x with the FIR filter.
filtered_x = lfilter(taps, 1.0, x)
figure(1)
plot(times, voltage)
xlabel("Time [s]")
ylabel("Voltage [mV]")
title("Load Cell Voltage v. Time")
grid(True)
show()
def xkcd_line(x, y, xlim=None, ylim=None,
mag=1.0, f1=30, f2=0.05, f3=15):
"""
Mimic a hand-drawn line from (x, y) data
Parameters
----------
x, y : array_like
arrays to be modified
xlim, ylim : data range
the assumed plot range for the modification. If not specified,
they will be guessed from the data
mag : float
magnitude of distortions
f1, f2, f3 : int, float, int
filtering parameters. f1 gives the size of the window, f2 gives
the high-frequency cutoff, f3 gives the size of the filter
Returns
-------
x, y : ndarrays
The modified lines
"""
x = np.asarray(x)
y = np.asarray(y)
# get limits for rescaling
if xlim is None:
xlim = (x.min(), x.max())
if ylim is None:
ylim = (y.min(), y.max())
if xlim[1] == xlim[0]:
xlim = ylim
if ylim[1] == ylim[0]:
ylim = xlim
# scale the data
x_scaled = (x - xlim[0]) * 1. / (xlim[1] - xlim[0])
y_scaled = (y - ylim[0]) * 1. / (ylim[1] - ylim[0])
# compute the total distance along the path
dx = x_scaled[1:] - x_scaled[:-1]
dy = y_scaled[1:] - y_scaled[:-1]
dist_tot = np.sum(np.sqrt(dx * dx + dy * dy))
# number of interpolated points is proportional to the distance
Nu = int(200 * dist_tot)
u = np.arange(-1, Nu + 1) * 1. / (Nu - 1)
# interpolate curve at sampled points
k = min(3, len(x) - 1)
res = interpolate.splprep([x_scaled, y_scaled], s=0, k=k)
x_int, y_int = interpolate.splev(u, res[0])
# we'll perturb perpendicular to the drawn line
dx = x_int[2:] - x_int[:-2]
dy = y_int[2:] - y_int[:-2]
dist = np.sqrt(dx * dx + dy * dy)
# create a filtered perturbation
coeffs = mag * np.random.normal(0, 0.01, len(x_int) - 2)
b = signal.firwin(f1, f2 * dist_tot, window=('kaiser', f3))
response = signal.lfilter(b, 1, coeffs)
x_int[1:-1] += response * dy / dist
y_int[1:-1] += response * dx / dist
# un-scale data
x_int = x_int[1:-1] * (xlim[1] - xlim[0]) + xlim[0]
y_int = y_int[1:-1] * (ylim[1] - ylim[0]) + ylim[0]
return x_int, y_int
def bandpass_firwin(ntaps, lowcut, highcut, fs, window='hamming'):
nyq = 0.5 * fs
taps = firwin(ntaps, [lowcut, highcut], nyq=nyq, pass_zero=False,
window=window, scale=False)
return taps
DCnotchZi2 = np.zeros([8,1])
#Butterworth lowpass filter
N = 4 # Filter order
fk = 30
Wn = fk/(fs/2) # Cutoff frequency
lowpassB, lowpassA = signal.butter(N, Wn, output='ba')
lowpassZi = np.zeros([8,N])
#FIR bandpass filter
hcc = 56.0/(fs/2)
hc = 44.0/(fs/2) #High cut
lc = 5.0/(fs/2) #Low cut
bandpassB = signal.firwin(window, [lc, hc], pass_zero=False, window = 'hann') #Bandpass
bandpassA = 1.0 #np.ones(len(bandpassA))
bandpassZi = np.zeros([8, window-1])
highpassB = signal.firwin(window, lc, pass_zero=False, window = 'hann') #Bandpass
highpassA = 1.0
highpassZi = np.zeros([8, window-1])
print("Filtersetup finished")
multibandB = signal.firwin(window, hc, pass_zero=True, window = 'hann') #Bandpass
multibandA = 1.0
multibandZi = np.zeros([8, window-1])
def dataCatcher():
global board
board.start_streaming(printData)
dt = 1/F_SAMPLE
time = np.linspace(0, LEN_DATA*dt, LEN_DATA)
time_long = np.linspace(0, 4096*dt, 4096)
freq = np.linspace(0.0, F_SAMPLE//2, LEN_DATA//2)
freq_long = np.linspace(0, F_SAMPLE//2, 4096//2)
data = np.genfromtxt("../accelerometer_calibration/4kHz.txt", delimiter=',')
x_long = np.genfromtxt("../accelerometer_calibration/4kHz_x.txt", delimiter=',')
x_long = Data(x_long)
x_data = Data(data[:, 0])
y_data = Data(data[:, 1])
z_data = Data(data[:, 2])
numtaps = 30
taps = signal.firwin(numtaps, 4/F_SAMPLE, window='blackman')
filtered_x = signal.lfilter(taps, 1.0, x_long.data)
#------------------------------------------------
# Plot the FIR filter coefficients.
#------------------------------------------------
plt.figure(1)
plt.plot(taps, 'bo-', linewidth=2)
plt.title('Filter Coefficients (%d taps)' % numtaps)
plt.grid(True)
#------------------------------------------------
# Plot the magnitude response of the filter.
#------------------------------------------------
def process(self, data, parameters):
if parameters[0] == 'B': #Bandpass Filter
if np.array(parameters.split(',')).size == 4:
#Estimate Filter coefficients
parameter = np.array(parameters.split(','))
p = np.array(parameter)
n = int(p[3])
a = signal.firwin(n, np.float(p[1]))
b = -signal.firwin(n, np.float(p[2]))
b[n / 2] = b[n / 2] + 1
d = -(a + b)
d[n / 2] = d[n / 2] + 1
w1, FilterCoef = signal.freqz(d)
FilterCoefLength = FilterCoef.size
#Filter Data with estimated coefficients
Data = np.transpose(np.array(data))
size = Data.shape
FilteredData = np.zeros((size[0], size[1]))
for c in range(0, size[0]):
FilteredData[c, :] = signal.lfilter(FilterCoef, 1, Data)
result = pd.DataFrame(np.transpose((FilteredData)))
else:
result = np.zeros(1000)
result = pd.DataFrame(np.transpose((result)))
if parameters[0] == 'L': #LowPass Filter
if np.array(parameters.split(',')).size == 3:
#Estimate Filter coefficients
parameter = np.array(parameters.split(','))
p = np.array(parameter)
n = int(p[2])
a = signal.firwin(n, np.float(p[1]))
w1, FilterCoef = signal.freqz(a)
FilterCoefLength = FilterCoef.size
#Filter Data with estimated coefficients
Data = np.transpose(np.array(data))
size = Data.shape
FilteredData = np.zeros((size[0], size[1]))
for c in range(0, size[0]):
FilteredData[c, :] = signal.lfilter(FilterCoef, 1, Data)
result = pd.DataFrame(np.transpose((FilteredData)))
else:
result = np.zeros(1000)
result = pd.DataFrame(np.transpose((result)))
if parameters[0] == 'H': #Highpass Filter
if np.array(parameters.split(',')).size == 3:
#Estimate Filter coefficients
parameter = np.array(parameters.split(','))
p = np.array(parameter)
n = int(p[2])
b = -signal.firwin(n, np.float(p[1]))
b[n / 2] = b[n / 2] + 1
w1, FilterCoef = signal.freqz(b)
FilterCoefLength = FilterCoef.size
#Filter Data with estimated coefficients
Data = np.transpose(np.array(data))
size = Data.shape
FilteredData = np.zeros((size[0], size[1]))
for c in range(0, size[0]):
FilteredData[c, :] = signal.lfilter(FilterCoef, 1, Data)
result = pd.DataFrame(np.transpose((FilteredData)))
else:
result = np.zeros(1000)
result = pd.DataFrame(np.transpose((result)))
return result
def createfilter(self, filterorder, cutoff):
self.filter = sig.firwin(filterorder, cutoff)
## FIRWIN: Filterentwurf mit gefensterter (Default: Hamming)
# Fourier-Approximation (entspricht fir1 bei Matlab / Octave)
# scipy.signal.firwin(numtaps, cutoff, width=None, window='hamming',
# pass_zero=True, scale=True, nyq=1.0)
#
if FILT_FIR_METHOD == 'WIN':
#
# Hier wird die -6 dB Grenzfrequenz ( bezogen auf f_S/2 ) spezifiziert,
# kein Ãbergangsbereich wie bei firls -> ungÃŒnstig, da ein don't care -
# Bereich zwischen f_DB und f_SB nicht gezielt ausgenutzt werden kann!
# DafÃŒr kann ÃŒber die Auswahl des Fenstertyps "Finetuning" betrieben werden.
# Mit pass_zero = True wird |H(f=0)| = 1 (Tiefpass, BP),
# mit pass_zero = False wird |H(f=f_S/2| = 1 (Hochpass, BS) erzwungen.
# FÃŒr alle Filtertypen definiert der Frequenzvektor F die Eckfrequenzen
# der DurchlassbÀnder. F=[0.35 0.55] und pass_zero = 1 erzeugt Bandpass
bb = sig.firwin(L, F_DB * 2.0, window=FILT_FIR_WINDOW)
elif FILT_FIR_METHOD == 'WIN2':
#=======================================================================
## FIRWIN2: Frequency Sampling FIR-Filterentwurf: Es wird ein linearphas.
# Filter erzeugt, das bei den Frequenzen 'freq' die VerstÀrkung
# 'gain' hat (entsprechend fir2 bei Matlab / Octave)
# scipy.signal.firwin2(numtaps, freq, gain, nfreqs=None, window='hamming',
# nyq=1.0, antisymmetric=False)
#
# Mit antisymmetric = True werden Filter mit ungerader Symmetrie gewÀhlt
# (Typ III oder IV), je nachdem ob numtaps gerade oder ungerade ist, wird
# der Typ weiter eingeschrÀnkt.
bb = sig.firwin2(L, [0, F_DB, F_SB, 1], [1, 1, 0, 0],
window=FILT_FIR_WINDOW)
# Example for Multi-band Hilbert Filter taken from Matlab firls reference
class Algorithm:
# Initial parameters
Fs = 200 # Data packs come in every 5ms = 200Hz
wsize1 = 0.15 # MAF (moving average filter) size for Energy Level Detection, size of 1st MAF
wsize2 = 0.2 # MAF size for Energy Variation Detection, size of 2nd MAF
refractory_time = 0.15 # Refractory Period
thEL0 = 0.1 # Initial value for energy level threshold
stabLevel = 0.5 # Stabilization Reference Voltage
r_a = 0.1 # application rate for weight adjustment
r_b = 0.05 # application rate for weight adjustment
r_nr = 1.75 # application rate of noise level (for signal threshold)
r_s = 0.001 # application rate of signal level (for noise threshold)
r_d = 0.05 # decay rate for adaptive threshold
r_n = 0.03 # application rate of noise level (for signal threshold)
Weight = 1 # weight for adjustment signal level
winsizeEL = round(wsize1 * Fs) # window size for Energy Level (EL)
winsizeEV = round(wsize2 * Fs) # window size for Energy Variation (EV)
diffWinsize = winsizeEV - winsizeEL # difference in window sizes
refractoryP = round(refractory_time * Fs) # refractory period
thEVlimit = 1 * Fs / (0.2 * Fs * 20)
thEVub = 0.45 * Fs / (0.2 * Fs * 20)
thEVlb = -0.45 * Fs / (0.2 * Fs * 20)
thEVub2 = 20 * Fs / (0.2 * Fs * 20)
thEVlb2 = -20 * Fs / (0.2 * Fs * 20)
ArrayL = 5
decayF = 1 - 1 / ((0.40 - refractory_time) * Fs)
checker2 = 0
isStart = 0
maxV_Buf = None
maxV = 1
QRScount = 0
cutoffs = np.array([
(5 / (Fs / 2)), (25 / (Fs / 2))
]) # Cutoff frequencies for the bandpass filter (5Hz - 25Hz)
maxVArray = np.zeros((ArrayL, 1))
maxDifBuf = np.zeros((ArrayL, 1))
minDifBuf = np.zeros((ArrayL, 1))
BUF1 = np.zeros((winsizeEL, 1))
BUF2 = np.zeros((winsizeEV, 1))
# Expand the following arrays within the iterate array
ELQRS = np.asarray([])
EVQRS = np.asarray([])
thEL = np.asarray([]) # Threshold for EL (Adaptive threshold)
thEV = np.asarray([]) # Threshold for EV (Hard threshold)
thN = np.asarray([])
mem_allocation = 0 # Dummy counter to initialize these arrays
kk = winsizeEV # Counter
# If the signal length gets readjusted each time, is this even necssary? couldn't I just take the last index of the array?
# maybe set kk = len(data) or whatever
# Initializes variables that are calculated later within the iterate function
Timer = -1
TimerOfPeak = -1
maxP = -1
maxP_Buf = -1
BufStartP2 = -1
BufEndP2 = -1
# Window coefficients for the filter in the iterate function
b = signal.firwin(64, cutoffs, pass_zero=False)
# Initializes the algorithm object by taking in a lead, which at this stage is more for labelling purposes than anything
# Also sets up an empty array to store QRS locations in
def __init__(self, lead):
self.lead = lead # Labels the algorithm w/ the corresponding lead
self.qrsLocs = np.asarray(
[]) # Stores locations of detected QRS complexes
# This function runs 1 iteration of the algorithm & is to be called after reading in a single data point.
# It also saves any detected QRS points in a text file.
def iterate(self, data, file):
current_time = time.process_time()
# Preprocessing, filters the signal
#fSig = signal.filtfilt(b, [1], data, axis=0)
fSig = signal.lfilter(self.b, [1], data,
axis=0) # Signal after bandpass filter
sSig = np.sqrt(fSig**2) # Signal after squaring
dSig = self.Fs * np.concatenate(([0], np.diff(sSig, axis=0)),
axis=0) # Signal after differentiating
sigLen = len(sSig)
filter_time = time.process_time() - current_time
print('Filter time: ' + str(filter_time))
#print('---')
#Initializes the arrays, then expands them each iteration after that
if self.mem_allocation == 0:
self.ELQRS = np.zeros((sigLen, 1))
self.EVQRS = np.zeros((sigLen, 1))
self.thEL = np.ones((sigLen, 1)) * self.thEL0
self.thEV = np.zeros((sigLen - 1, 1))
self.thN = np.zeros((sigLen, 1))
self.mem_allocation = 1
else:
self.ELQRS = np.concatenate((self.ELQRS, [[0]]))
self.EVQRS = np.concatenate((self.EVQRS, [[0]]))
self.thEL = np.concatenate((self.thEL, [[self.thEL0]]))
self.thEV = np.concatenate((self.thEV, [[0]]))
self.thN = np.concatenate((self.thN, [[0]]))
LargeWin = self.winsizeEV
### Moving average w/ weight ###
if self.kk == 193:
#if self.kk == LargeWin:
for i in np.arange(len(self.BUF1), self.kk - 1):
self.BUF1 = np.concatenate((self.BUF1, [[0]]), axis=0)
self.BUF1 = np.concatenate((self.BUF1, [[
(np.sum(sSig[self.kk - self.winsizeEL:self.kk], axis=0) /
self.winsizeEL)
]]),
axis=0)
self.BUF2 = np.concatenate((self.BUF2, [[
(np.sum(dSig[self.kk - self.winsizeEV:self.kk], axis=0) /
self.winsizeEV)
]]),
axis=0)
self.ELQRS[self.kk - 1] = np.sum(np.copy(
self.BUF1[self.kk - self.winsizeEL:self.kk]),
axis=0) / self.winsizeEL
self.EVQRS[self.kk - 1] = np.sum(np.copy(
self.BUF2[self.kk - self.winsizeEV:self.kk]),
axis=0) / self.winsizeEV
### Step 1: Energy Level Detection ###
if self.isStart == 0 and self.ELQRS[self.kk - 1] >= self.thEL[self.kk -
1]:
self.thEL[self.kk - 1] = np.copy(self.ELQRS[self.kk - 1])
self.maxV = np.copy(self.ELQRS[self.kk - 1])
self.maxP = self.kk - 1
self.isStart = 1
if self.ELQRS[self.kk - 1] < self.thN[self.kk - 1]:
self.thN[self.kk - 1] = np.copy(self.ELQRS[self.kk - 1])
if self.isStart == 1:
if self.ELQRS[self.kk - 1] >= self.maxV:
self.thEL[self.kk - 1] = np.copy(self.ELQRS[self.kk - 1])
self.maxV = np.copy(self.ELQRS[self.kk - 1])
self.maxP = self.kk - 1
self.Timer = self.refractoryP
else:
self.Timer = self.Timer - 1
self.thEL[self.kk - 1] = self.maxV
if self.Timer == 0:
self.isStart = 0
self.checker2 = 1
self.TimerOfPeak = self.winsizeEV - (self.refractoryP -
self.winsizeEL)
self.maxP_Buf = self.maxP
self.maxV_Buf = self.maxV
### Step 2: Energy Variation Detection ###
if self.checker2 == 1:
self.TimerOfPeak = self.TimerOfPeak - 1
if self.TimerOfPeak == 0:
self.checker2 = 0
if self.maxP_Buf - self.winsizeEL < 1:
self.BufStartP2 = 1
else:
self.BufStartP2 = self.maxP_Buf - self.winsizeEL
if self.maxP_Buf + 2 * self.diffWinsize > sigLen:
self.BufEndP2 = data.size
else:
self.BufEndP2 = self.maxP_Buf + 2 * self.diffWinsize * 2
DiffSumCheck1 = np.amax(np.copy(
self.EVQRS[(self.BufStartP2 - 1):(self.maxP_Buf +
self.diffWinsize)]),
axis=0)
DiffSumCheck2 = np.amin(np.copy(
self.EVQRS[(self.maxP_Buf + self.diffWinsize -
1):self.BufEndP2]),
axis=0)
if self.qrsLocs.size == 0 or (
DiffSumCheck1 - DiffSumCheck2 > self.thEVlimit
and DiffSumCheck1 * DiffSumCheck2 < 0
and DiffSumCheck1 > self.thEVub
and DiffSumCheck2 < self.thEVlb
and DiffSumCheck1 < self.thEVub2
and DiffSumCheck2 > self.thEVlb2):
self.QRScount = self.QRScount + 1
self.qrsLocs = np.concatenate(
(self.qrsLocs,
np.copy([self.maxP_Buf - self.winsizeEL + 2])),
axis=0)
file.write(
str(np.copy([self.maxP_Buf - self.winsizeEL + 2])) +
'\n')
### Step 3: Weight Adjustment ###
self.maxVArray[(self.QRScount %
self.ArrayL)] = self.maxV_Buf
self.maxDifBuf[(self.QRScount % self.ArrayL)] = np.amax(
np.copy(self.EVQRS[(self.BufStartP2 -
1):self.BufEndP2]),
axis=0)
self.minDifBuf[(self.QRScount % self.ArrayL)] = np.amin(
np.copy(self.EVQRS[(self.BufStartP2 -
1):self.BufEndP2]),
axis=0)
if self.stabLevel > np.mean(self.maxVArray, axis=0):
AdujR1 = np.amin([
self.r_a *
(self.stabLevel -
np.median(np.copy(self.maxVArray), axis=0)),
self.r_b * self.stabLevel
],
axis=0)
else:
AdujR1 = np.amin([
self.r_a *
(self.stabLevel -
np.median(np.copy(self.maxVArray), axis=0)),
-1 * self.r_b * self.stabLevel
],
axis=0)
self.Weight = self.Weight + AdujR1
self.thN[self.kk] = np.copy(
self.thN[self.kk -
1]) + self.r_s * np.copy(self.ELQRS[self.kk - 1])
if self.maxV_Buf is not None:
self.thEL[self.kk] = np.copy(self.thEL[self.kk - 1]) * (
self.decayF *
(1 - self.r_d *
(np.copy(self.thN[self.kk - 1]) / self.maxV_Buf))
) + self.r_n * np.copy(self.thN[self.kk - 1])
else:
self.thEL[self.kk] = np.copy(self.thEL[self.kk - 1]) * self.decayF
if self.thEL[self.kk] < self.r_nr * self.thN[self.kk - 1]:
self.thEL[self.kk] = self.r_nr * np.copy(self.thN[self.kk - 1])
self.kk = self.kk + 1 #is this necessary?
def run_temporal(self, checkpoint_dir, vid_dir, frame_ext, out_dir,
amplification_factor, fl, fh, fs, n_filter_tap,
filter_type):
"""Magnify video with a temporal filter.
Args:
checkpoint_dir: checkpoint directory.
vid_dir: directory containing video frames videos are processed
in sorted order.
out_dir: directory to place output frames and resulting video.
amplification_factor: the amplification factor,
with 0 being no change.
fl: low cutoff frequency.
fh: high cutoff frequency.
fs: sampling rate of the video.
n_filter_tap: number of filter tap to use.
filter_type: Type of filter to use. Can be one of "fir",
"butter", or "differenceOfIIR". For "differenceOfIIR",
fl and fh specifies rl and rh coefficients as in Wadhwa et al.
"""
nyq = fs / 2.0
if filter_type == 'fir':
filter_b = firwin(n_filter_tap, [fl, fh], nyq=nyq, pass_zero=False)
filter_a = []
elif filter_type == 'butter':
filter_b, filter_a = butter(n_filter_tap, [fl / nyq, fh / nyq],
btype='bandpass')
filter_a = filter_a[1:]
elif filter_type == 'differenceOfIIR':
# This is a copy of what Neal did. Number of taps are ignored.
# Treat fl and fh as rl and rh as in Wadhwa's code.
# Write down the difference of difference equation in Fourier
# domain to proof this:
filter_b = [fh - fl, fl - fh]
filter_a = [-1.0 * (2.0 - fh - fl), (1.0 - fl) * (1.0 - fh)]
else:
raise ValueError('Filter type must be either '
'["fir", "butter", "differenceOfIIR"] got ' + \
filter_type)
head, tail = os.path.split(out_dir)
tail = tail + '_fl{}_fh{}_fs{}_n{}_{}'.format(fl, fh, fs, n_filter_tap,
filter_type)
out_dir = os.path.join(head, tail)
vid_name = os.path.basename(out_dir)
# make folder
mkdir(out_dir)
vid_frames = sorted(glob(os.path.join(vid_dir, '*.' + frame_ext)))
first_frame = vid_frames[0]
im = imread(first_frame)
image_height, image_width = im.shape
if not self.is_graph_built:
self.image_width = image_width
self.image_height = image_height
# Figure out image dimension
self._build_IIR_filtering_graphs()
ginit_op = tf.global_variables_initializer()
linit_op = tf.local_variables_initializer()
self.sess.run([ginit_op, linit_op])
if self.load(checkpoint_dir):
print("[*] Load Success")
else:
raise RuntimeError('MagNet: Failed to load checkpoint file.')
self.is_graph_built = True
try:
i = int(self.ckpt_name.split('-')[-1])
print("Iteration number is {:d}".format(i))
vid_name = vid_name + '_' + str(i)
except:
print("Cannot get iteration number")
if len(filter_a) is not 0:
x_state = []
y_state = []
for frame in tqdm(vid_frames, desc='Applying IIR'):
file_name = os.path.basename(frame)
frame_no, _ = os.path.splitext(file_name)
frame_no = int(frame_no)
in_frames = [
load_train_data([frame, frame, frame],
gray_scale=self.n_channels == 1,
is_testing=True)
]
in_frames = np.array(in_frames).astype(np.float32)
texture_enc, x = self.sess.run(
[self.texture_enc, self.shape_rep],
feed_dict={
self.input_image: in_frames[:, :, :, :3],
})
x_state.insert(0, x)
# set up initial condition.
while len(x_state) < len(filter_b):
x_state.insert(0, x)
if len(x_state) > len(filter_b):
x_state = x_state[:len(filter_b)]
y = np.zeros_like(x)
for i in range(len(x_state)):
y += x_state[i] * filter_b[i]
for i in range(len(y_state)):
y -= y_state[i] * filter_a[i]
# update y state
y_state.insert(0, y)
if len(y_state) > len(filter_a):
y_state = y_state[:len(filter_a)]
out_amp = self.sess.run(self.output_image,
feed_dict={
self.out_texture_enc:
texture_enc,
self.filtered_enc:
y,
self.ref_shape_enc:
x,
self.amplification_factor:
[amplification_factor]
})
im_path = os.path.join(out_dir, file_name)
out_amp = np.squeeze(out_amp)
out_amp = (127.5 * (out_amp + 1)).astype('uint8')
cv2.imwrite(im_path,
cv2.cvtColor(out_amp, code=cv2.COLOR_RGB2BGR))
else:
# This does FIR in fourier domain. Equivalent to cyclic
# convolution.
x_state = None
for i, frame in tqdm(enumerate(vid_frames),
desc='Getting encoding'):
file_name = os.path.basename(frame)
in_frames = [
load_train_data([frame, frame, frame],
gray_scale=self.n_channels == 1,
is_testing=True)
]
in_frames = np.array(in_frames).astype(np.float32)
texture_enc, x = self.sess.run(
[self.texture_enc, self.shape_rep],
feed_dict={
self.input_image: in_frames[:, :, :, :3],
})
if x_state is None:
x_state = np.zeros(x.shape + (len(vid_frames), ),
dtype='float32')
x_state[:, :, :, :, i] = x
filter_fft = np.fft.fft(np.fft.ifftshift(filter_b),
n=x_state.shape[-1])
# Filtering
for i in trange(x_state.shape[1], desc="Applying FIR filter"):
x_fft = np.fft.fft(x_state[:, i, :, :], axis=-1)
x_fft *= filter_fft[np.newaxis, np.newaxis, np.newaxis, :]
x_state[:, i, :, :] = np.fft.ifft(x_fft)
for i, frame in tqdm(enumerate(vid_frames), desc='Decoding'):
file_name = os.path.basename(frame)
frame_no, _ = os.path.splitext(file_name)
frame_no = int(frame_no)
in_frames = [
load_train_data([frame, frame, frame],
gray_scale=self.n_channels == 1,
is_testing=True)
]
in_frames = np.array(in_frames).astype(np.float32)
texture_enc, _ = self.sess.run(
[self.texture_enc, self.shape_rep],
feed_dict={
self.input_image: in_frames[:, :, :, :3],
})
out_amp = self.sess.run(self.output_image,
feed_dict={
self.out_texture_enc:
texture_enc,
self.filtered_enc:
x_state[:, :, :, :, i],
self.ref_shape_enc:
x,
self.amplification_factor:
[amplification_factor]
})
im_path = os.path.join(out_dir, file_name)
out_amp = np.squeeze(out_amp)
out_amp = (127.5 * (out_amp + 1)).astype('uint8')
cv2.imwrite(im_path,
cv2.cvtColor(out_amp, code=cv2.COLOR_RGB2BGR))
del x_state
# Try to combine it into a video
call([
DEFAULT_VIDEO_CONVERTER, '-y', '-f', 'image2', '-r', '30', '-i',
os.path.join(out_dir, '%06d.png'), '-c:v', 'libx264',
os.path.join(out_dir, vid_name + '.mp4')
])
def LP_filter_preprocess_signal(signal_data, T, num_samples, f_s):
nyq_rate = f_s / 2.0
# The desired width of the transition from pass to stop, relative to the Nyquist rate. We'll design the filter
# with a 5 Hz transition width.
# width = 5.0 / nyq_rate # FIXME: large the (5.) distortion span is less !
width = 100.0 / nyq_rate # GOOD; but smoothing is higher
# width = 20.0 / nyq_rate
# The desired attenuation in the stop band, in dB.
ripple_db = 60.0
# Compute the order and Kaiser parameter for the FIR filter.
N, beta = kaiserord(ripple_db, width)
# The cutoff frequency of the filter.
cutoff_hz = 60.0
# Use firwin with a Kaiser window to create a lowpass FIR filter.
taps = firwin(N, cutoff_hz / nyq_rate, window=('kaiser', beta))
# Use lfilter to filter x with the FIR filter.
filtered_x = lfilter(taps, 1.0, signal_data)
# ------------------------------------------------
# Plot the FIR filter coefficients.
# ------------------------------------------------
if DO_PLOT and not DO_DISABLE:
plt.figure(3)
plt.plot(taps, 'bo-', linewidth=2)
plt.title('Filter Coefficients (%d taps)' % N)
plt.grid(True)
plt.savefig("FIR_filter_coefficients.png")
# ------------------------------------------------
# Plot the magnitude response of the filter.
# ------------------------------------------------
w, h = freqz(taps, worN=8000)
if DO_PLOT and not DO_DISABLE:
plt.figure(4)
plt.clf()
plt.plot((w / np.pi) * nyq_rate, np.absolute(h), linewidth=2)
plt.xlabel('Frequency (Hz)')
plt.ylabel('Gain')
plt.title('Frequency Response')
plt.ylim(-0.05, 1.05)
plt.grid(True)
# Upper inset plot.
if DO_PLOT and not DO_DISABLE:
ax1 = plt.axes([0.42, 0.6, .45, .25])
plt.plot((w / np.pi) * nyq_rate, np.absolute(h), linewidth=2)
plt.xlim(0, 8.0)
plt.ylim(0.9985, 1.001)
plt.grid(True)
# Lower inset plot
if DO_PLOT and not DO_DISABLE:
ax2 = plt.axes([0.42, 0.25, .45, .25])
plt.plot((w / np.pi) * nyq_rate, np.absolute(h), linewidth=2)
plt.xlim(12.0, 20.0)
plt.ylim(0.0, 0.0025)
plt.grid(True)
plt.savefig("FIR_filter_magnitude_response.png")
# ------------------------------------------------
# Plot the original and filtered signals.
# ------------------------------------------------
# The phase delay of the filtered signal.
delay = 0.5 * (N - 1) / f_s
t = np.linspace(0, 1, num_samples)
front_pad = np.zeros(int(np.floor((N - 1) / 2)))
back_pad = np.zeros(int(np.ceil((N - 1) / 2)))
processed_sig = np.append(np.append(front_pad, filtered_x[N - 1:]),
back_pad)
if DO_PLOT:
plt.figure(5)
# Plot the original signal.
plt.plot(t, signal_data)
# Plot the filtered signal, shifted to compensate for the phase delay.
# plt.plot(t - delay, filtered_x, 'r-') # FIXME:
# Plot just the "good" part of the filtered signal. The first N-1
# samples are "corrupted" by the initial conditions.
# plt.plot(t[N - 1:] - delay, filtered_x[N - 1:], 'g', linewidth=2) # FIXME:
plt.xlabel('t')
plt.grid(True)
plt.plot(t, processed_sig, 'g', linewidth=2)
plt.savefig("FIR_LP_filtered_signal.png")
plt.show()
return processed_sig, T, N, f_s
def stereo_fm(x, fs=2.4e6, file_name='test.wav'):
"""
Stereo demod from complex baseband at sampling rate fs.
Assume fs is 2400 ksps
Mark Wickert July 2017
"""
N1 = 10
b = signal.firwin(64, 2 * 200e3 / float(fs))
# Filter and decimate (should be polyphase)
y = signal.lfilter(b, 1, x)
z = ss.downsample(y, N1)
# Apply complex baseband discriminator
z_bb = discrim(z)
# Work with the (3) stereo multiplex signals:
# Begin by designing a lowpass filter for L+R and DSP demoded (L-R)
# (fc = 12 KHz)
b12 = signal.firwin(128, 2 * 12e3 / (float(fs) / N1))
# The L + R term is at baseband, we just lowpass filter to remove
# other terms above 12 kHz.
y_lpr = signal.lfilter(b12, 1, z_bb)
b19 = signal.firwin(128, 2 * 1e3 * np.array([19 - 5, 19 + 5]) / (float(fs) / N1),
pass_zero=False);
z_bb19 = signal.lfilter(b19, 1, z_bb)
# Lock PLL to 19 kHz pilot
# A type 2 loop with bandwidth Bn = 10 Hz and damping zeta = 0.707
# The VCO quiescent frequency is set to 19000 Hz.
theta, phi_error = pilot_pll(z_bb19, 19000, fs / N1, 2, 10, 0.707)
# Coherently demodulate the L - R subcarrier at 38 kHz.
# theta is the PLL output phase at 19 kHz, so to double multiply
# by 2 and wrap with cos() or sin().
# First bandpass filter
b38 = signal.firwin(128, 2 * 1e3 * np.array([38 - 5, 38 + 5]) / (float(fs) / N1),
pass_zero=False);
x_lmr = signal.lfilter(b38, 1, z_bb)
# Coherently demodulate using the PLL output phase
x_lmr = 2 * np.sqrt(2) * np.cos(2 * theta) * x_lmr
# Lowpass at 12 kHz to recover the desired DSB demod term
y_lmr = signal.lfilter(b12, 1, x_lmr)
# Matrix the y_lmr and y_lpr for form right and left channels:
y_left = y_lpr + y_lmr
y_right = y_lpr - y_lmr
# Decimate by N2 (nominally 5)
N2 = 5
fs2 = float(fs) / (N1 * N2) # (nominally 48 ksps)
y_left_DN2 = ss.downsample(y_left, N2)
y_right_DN2 = ss.downsample(y_right, N2)
# Deemphasize with 75 us time constant to 'undo' the preemphasis
# applied at the transmitter in broadcast FM.
# A 1-pole digital lowpass works well here.
a_de = np.exp(-2.1 * 1e3 * 2 * np.pi / fs2)
z_left = signal.lfilter([1 - a_de], [1, -a_de], y_left_DN2)
z_right = signal.lfilter([1 - a_de], [1, -a_de], y_right_DN2)
# Place left and righ channels as side-by-side columns in a 2D array
z_out = np.hstack((np.array([z_left]).T, (np.array([z_right]).T)))
ss.to_wav(file_name, 48000, z_out / 2)
print('Done!')
# return z_bb, z_out
return z_bb, theta, y_lpr, y_lmr, z_out
def __init__(self,
fs=48000.0,
Abuffer=1024,
Nchunks=43,
baud=2400,
mark_f=1200,
space_f=2400):
# Implementation of an afsk1200 TNC.
#
# The TNC processes a `Abuffer` long buffers, till `Nchunks` number of buffers are collected into a large one.
# This is because python is able to more efficiently process larger buffers than smaller ones.
# Then, the resulting large buffer is demodulated, sampled and packets extracted.
#
# Inputs:
# fs - sampling rate
# TBW - TBW of the demodulator filters
# Abuffer - Input audio buffers from Pyaudio
# Nchunks - Number of audio buffers to collect before processing
# plla - agressivness parameter of the PLL
## compute sizes based on inputs
self.baud = baud
self.mark_f = mark_f
self.space_f = space_f
self.TBW = 2.0 # TBW for the demod filters
self.N = (int(fs / baud * self.TBW) //
2) * 2 + 1 # length of the filters for demod
self.fs = fs # sampling rate
self.BW = self.TBW / (1.0 * self.N / fs) # BW of filter based on TBW
self.Abuffer = Abuffer # size of audio buffer
self.Nchunks = Nchunks # number of audio buffers to collect
self.Nbuffer = Abuffer * Nchunks + self.N * 3 - 3 # length of the large buffer for processing
self.Ns = 1.0 * fs / baud # samples per symbol
## state variables for the modulator
self.prev_ph = 0 # previous phase to maintain continuous phase when recalling the function
## Generate Filters for the demodulator
self.h_lp = signal.firwin(self.N, self.BW / fs * 1.0, window='hanning')
self.h_lpp = signal.firwin(self.N,
self.BW * 2 * 1.2 / fs,
window='hanning')
self.h_space = self.h_lp * exp(
1j * 2 * pi * (self.space_f) * r_[-self.N / 2:self.N / 2] / fs)
self.h_mark = self.h_lp * exp(
1j * 2 * pi * (self.mark_f) * r_[-self.N / 2:self.N / 2] / fs)
fc = (self.space_f + self.mark_f) / 2
self.h_bp = signal.firwin(
self.N, self.BW / fs * 2.2, window='hanning') * exp(
1j * 2 * pi * fc * r_[-self.N / 2:self.N / 2] / fs)
## PLL state variables -- so conntinuity between buffers is preserved
self.dpll = np.round(2.0**32 / self.Ns).astype(int32) # PLL step
self.pll = 0 # PLL counter
self.ppll = -self.dpll # PLL counter previous value -- to detect overflow
self.plla = 0.3 # PLL agressivness (small more agressive)
## state variable to NRZI2NRZ
self.NRZIprevBit = True
## State variables for findPackets
self.state = 'search' # state variable: 'search' or 'pkt'
self.pktcounter = 0 # counts the length of a packet
self.packet = bitarray.bitarray([0, 1, 1, 1, 1, 1, 1,
0]) # current packet being collected
self.bitpointer = 0 # poiter to advance the search beyond what was already searched in the previous buffer
## State variables for processBuffer
self.buff = zeros(self.Nbuffer) # large overlapp-save buffer
self.chunk_count = 0 # chunk counter
self.oldbits = bitarray.bitarray([
0, 0, 0, 0, 0, 0, 0
]) # bits from end of prev buffer to be copied to beginning of new
self.Npackets = 0 # packet counter
def Fast_Kurtogram(x, nlevel, Fs=1, opt1=None, opt2=None):
# Fast_Kurtogram(x,nlevel,Fs)
# Computes the fast kurtogram of signal x up to level 'nlevel'
# Maximum number of decomposition levels is log2(length(x)), but it is
# recommed to stay by a factor 1/8 below this.
# Fs = sampling frequency of signal x (default is Fs = 1)
# opt1 = 1: classical kurtosis based on 4th order statistics
# opt1 = 2: robust kurtosis based on 2nd order statistics of the envelope
# (if there is any difference in the kurtogram between the two measures, this is
# due to the presence of impulsive additive noise)
# opt2 = 1: the kurtogram is computed via a fast decimated filterbank tree
# opt2 = 2: the kurtogram is computed via the short-time Fourier transform
# (option 1 is faster and has more flexibility than option 2 in the design of the
# analysis filter: a short filter in option 1 gives virtually the same results as option 2)
#
# -------------------
# J. Antoni : 02/2005
# Translation to Python: T. Lecocq 02/2012
# -------------------
N = len(x)
N2 = np.log2(N) - 7
if nlevel > N2:
logging.error('Please enter a smaller number of decomposition levels')
if opt2 is None:
#~ opt2 = int(raw_input('Choose the kurtosis measure (classic = 1 robust = 2): '))
opt2 = 1
if opt1 is None:
#~ opt1 = int(raw_input('Choose the algorithm (filterbank = 1 stft-based = 2): '))
opt1 = 1
# Fast computation of the kurtogram
####################################
if opt1 == 1:
# 1) Filterbank-based kurtogram
############################
# Analytic generating filters
N = 16
fc = .4 # a short filter is just good enough!
h = si.firwin(N + 1, fc) * np.exp(
2 * 1j * np.pi * np.arange(N + 1) * 0.125)
n = np.arange(2, N + 2)
print(n)
g = h[(1 - n) % N] * (-1.)**(1 - n)
# g = np.power(h[(1-n)%N]*(-1), (1-n))
N = int(np.fix((3. / 2. * N)))
print(N)
h1 = si.firwin(N + 1, 2. / 3 * fc) * np.exp(
2j * np.pi * np.arange(N + 1) * 0.25 / 3.)
#~ plt.plot(h1)
#~ plt.show()
h2 = h1 * np.exp(2j * np.pi * np.arange(N + 1) / 6.)
h3 = h1 * np.exp(2j * np.pi * np.arange(N + 1) / 3.)
if opt2 == 1:
Kwav = K_wpQ(x, h, g, h1, h2, h3, nlevel,
'kurt2') # kurtosis of the complex envelope
#~ else:
#~ Kwav = K_wpQ(x,h,g,h1,h2,h3,nlevel,'kurt1') # variance of the envelope magnitude
# keep positive values only!
Kwav[Kwav <= 0] = 0
fig = plt.figure()
#~ plt.subplot(ratio='auto')
Level_w = np.arange(1, nlevel + 1)
Level_w = np.array([Level_w, Level_w + np.log2(3.) - 1])
Level_w = sorted(Level_w.ravel())
Level_w = np.append(0, Level_w[0:2 * nlevel - 1])
freq_w = Fs * (np.arange(0, 3 * 2.0**nlevel - 1 + 1)) / (
3 * 2**(nlevel + 1)) + 1.0 / (3. * 2.**(2 + nlevel))
Kwav_loc = []
n_crit = len(Kwav) - 2
Kwav_loc.append(list(Kwav[n_crit]))
for i in range(len(Kwav)):
if i != n_crit:
Kwav_loc.append(list(Kwav[i]))
# print(type(Kwav_loc))
# print(type(Kwav))
Kwav_loc = np.array(Kwav_loc)
print(Kwav_loc)
print(Kwav)
# print(type(Kwav_loc[0]))
# print(type(Kwav[0]))
# print(type(Kwav_loc[0][0]))
# print(type(Kwav[0][0]))
# sys.exit()
plt.imshow(Kwav_loc,
aspect='auto',
extent=(freq_w[0], freq_w[-1], Level_w[-1], Level_w[0]),
interpolation='none')
# plt.imshow(Kwav,aspect='auto',extent=(freq_w[0],freq_w[-1],Level_w[0],Level_w[-1]),interpolation='bilinear')
# print(Kwav)
index = np.argmax(Kwav_loc)
maxima_kurtosis = np.max(Kwav_loc)
index = np.unravel_index(index, Kwav_loc.shape)
f1 = freq_w[index[1]]
# l1 = Level_w[index[0]+1]
l1 = Level_w[index[0]]
fi = (index[1]) / 3. / 2**(nlevel + 1)
fi += 2.**(-2 - l1)
print(fi, l1, Fs * fi)
print('+++Max Kurtosis: ', maxima_kurtosis)
print('+++Center Freq: ', Fs * fi)
print('+++Level: ', l1)
print('+++Width Freq: ', Fs / 2.**(l1 + 1))
print('+++Lowpass Freq: ', Fs * fi - (Fs / 2.**(l1 + 1)) / 2.)
print('+++Highpass Freq: ', Fs * fi + (Fs / 2.**(l1 + 1)) / 2.)
plt.colorbar()
plt.show()
else:
logging.error('stft-based is not implemented')
#Ajouter le signal filtering !
c = []
#~ test = int(raw_input('Do you want to filter out transient signals from the kurtogram (yes = 1 ; no = 0): '))
test = 1
#~ fi = fi * Fs
lev = l1
while test == 1:
#~ fi = float(input([' Enter the optimal carrier frequency (btw 0 and ',num2str(Fs/2),') where to filter the signal: ']));
#~ fi = fi/Fs;
#~ if opt1 == 1:
#~ lev = input([' Enter the optimal level (btw 0 and ',num2str(nlevel),') where to filter the signal: ']);
if opt2 == 1:
c, Bw, fc = Find_wav_kurt(x, h, g, h1, h2, h3, nlevel, lev, fi,
'kurt2', Fs)
#~ else
#~ [c,Bw,fc] = Find_wav_kurt(x,h,g,h1,h2,h3,nlevel,lev,fi,'kurt1',Fs);
test = int(
raw_input(
'Do you want to keep on filtering out transients (yes = 1 ; no = 0): '
))
def firfedge(x, f_range, fs=1000, w=3):
nyq = np.float(fs / 2)
Ntaps = np.floor(w * fs / f_range[0])
taps = scsig.firwin(Ntaps, np.array(f_range) / nyq, pass_zero=False)
return scsig.filtfilt(taps, [1], x)
import numpy as np
from scipy import fftpack
from scipy import signal
import matplotlib.pyplot as plt
from matplotlib import mlab
n = 1024*4
fs = 512
dt = 1/fs
b = signal.firwin(30, 0.2, window="boxcar")
x = np.random.randn(n)
y = signal.filtfilt(b, 1, x)
w, h = signal.freqz(b, 1, fs)
plt.plot(w*fs/(2*np.pi), 20*np.log10(np.abs(h)), "b")
plt.xlim(0, fs/2)
plt.ylim(-120, 0)
plt.xlabel("Frequency[Hz]")
plt.ylabel("Amplitude[dB]")
plt.show()
idNumBin = BinArray(idNum, nBits)
txBin = idNumBin
preludeNBits = 16
# Add random binary data to ensure time for clock to lock before data bits
prelude = np.array(np.random.randint(2, size=preludeNBits), dtype="bool")
txBin = np.append(prelude, txBin)
carrierFreq = 1 / 32
nBits = 24 # Add differential encoding bit
bitPeriod = 128
# FIR Filter Design
nTaps = 128
cuttOffFrequency = 0.005
b1 = signal.firwin(nTaps, cuttOffFrequency)
w1, h1 = signal.freqz(b1)
# Create matched filter by reversing FIR response
b1 = np.flip(b1)
print("Unmodulated TX Data: ")
print(txBin)
# Differnetial Encoding
#difEncoded = DifferentialEncoder(txBin)
# Modulate Signal Using BPSK scheme
txBPSK = ModulationBPSK(txBin, bitPeriod, carrierFreq)
#difEncoded = DifferentialEncoder(txBin)
int(neuronID) for x in eventContent
if populationID == x[1] and neuronID == x[2] and x[3] == '0'
]
plt.eventplot(x, lineoffsets=int(neuronID), linelengths=0.7)
# plt.scatter(x, y)
plotValueOutputs('999', '0', '3', 'signal input')
# plotValueOutputs('1', '0', '3')
plotValueOutputs('321', '0', '3', 'decode output')
plotValueOutputs('1234', '0', '3', 'ann output')
# plotSpikeOutputs('5678', '0')
plotSpikeOutputs('93876079284464', '0')
# plotValueOutputs('94261706957552', '0', '0')
for i in range(1000):
# plt.axvline(x=0.1*i, color='r', linewidth=0.5)
pass
t = signal.firwin(24, 5, fs=100)
# plt.plot(t)
filt = ""
for s in t:
filt = filt + str(s) + ","
# print(filt)
plt.legend()
plt.show()
