def harris_ones(img, window_size, k=0.05):
"""Calculate the harris score based on a window function of diagonal ones.
Args:
img The image to use for corner detection.
window_size Size of the window (NxN).
k Weighting parameter during the final scoring (det vs. trace).
Returns:
Corner score image
"""
# Gradients
img = skiutil.img_as_float(img)
imgy, imgx = np.gradient(img)
imgxy = imgx * imgy
imgxx = imgx ** 2
imgyy = imgy ** 2
# window function (matrix of diagonal ones)
window = np.ones((window_size, window_size))
# compute parts of harris matrix
a11 = signal.correlate(imgxx, window, mode="same") / window_size
a12 = signal.correlate(imgxy, window, mode="same") / window_size
a21 = a12
a22 = signal.correlate(imgyy, window, mode="same") / window_size
# compute score per pixel
det_a = a11 * a22 - a12 * a21
trace_a = a11 + a22
return det_a - k * trace_a ** 2
def main():
"""Load image, apply sobel (to get x/y gradients), plot the results."""
img = data.camera()
sobel_y = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]])
sobel_x = np.rot90(sobel_y) # rotates counter-clockwise
# apply x/y sobel filter to get x/y gradients
img_sx = signal.correlate(img, sobel_x, mode="same")
img_sy = signal.correlate(img, sobel_y, mode="same")
# combine x/y gradients to gradient magnitude
# scikit-image's implementation divides by sqrt(2), not sure why
img_s = np.sqrt(img_sx ** 2 + img_sy ** 2) / np.sqrt(2)
# create binarized image
threshold = np.average(img_s)
img_s_bin = np.zeros(img_s.shape)
img_s_bin[img_s > threshold] = 1
# generate ground truth (scikit-image method)
ground_truth = skifilters.sobel(data.camera())
# plot
util.plot_images_grayscale(
[img, img_sx, img_sy, img_s, img_s_bin, ground_truth],
[
"Image",
"Sobel (x)",
"Sobel (y)",
"Sobel (magnitude)",
"Sobel (magnitude, binarized)",
"Sobel (Ground Truth)",
],
)
def test_consistency_correlate_funcs(self):
# Compare np.correlate, signal.correlate, signal.correlate2d
a = np.arange(5)
b = np.array([3.2, 1.4, 3])
for mode in ["full", "valid", "same"]:
assert_almost_equal(np.correlate(a, b, mode=mode), signal.correlate(a, b, mode=mode))
assert_almost_equal(np.squeeze(signal.correlate2d([a], [b], mode=mode)), signal.correlate(a, b, mode=mode))
def _setup_rank1(self, mode):
np.random.seed(9)
a = np.random.randn(10).astype(self.dt)
a += 1j * np.random.randn(10).astype(self.dt)
b = np.random.randn(8).astype(self.dt)
b += 1j * np.random.randn(8).astype(self.dt)
y_r = (correlate(a.real, b.real, mode=mode) + correlate(a.imag, b.imag, mode=mode)).astype(self.dt)
y_r += 1j * (-correlate(a.real, b.imag, mode=mode) + correlate(a.imag, b.real, mode=mode))
return a, b, y_r
def checkPathway(network, entry, keggDict, maxDelay, skip) :
netlist_e = [] # set of entry for each path [ set(0,1,2), set(0,1,2), set(2,3,4) ... ]
netlist_eg = [] # connected components for each path [ (0!g1->1!g2->2!g3), (0!g4->1!g5->2!g6), ... ]
netlist_cc = []
net_e = nx.DiGraph()
net_eg = nx.DiGraph()
for (a,b) in network.edges() :
type = network[a][b]['type']
e1 = entry[a]
e2 = entry[b]
for g1 in e1 :
for g2 in e2 :
if g1 not in keggDict or g2 not in keggDict :
continue
if checkProfile(keggDict[g1], keggDict[g2], type, maxDelay) :
net_e.add_edge(a, b)
net_eg.add_edge(a+'!'+g1, b+'!'+g2)
comps = nx.connected_components(net_eg.to_undirected())
temp = []
for c in comps :
real_c = map(lambda x: x.split('!')[1], c)
real_ce = set(map(lambda x: x.split('!')[0], c))
# Check if the same gene set w/ different entry name exists
if real_c not in temp and ((not skip) or len(real_ce)>2):
temp.append(real_c)
netlist_e.append(set(map(lambda x: x.split('!')[0], c)))
netlist_eg.append(net_eg.subgraph(c))
for eg in netlist_eg :
cc_e = {}
tempcc = 0
for (a, b) in eg.edges() :
e1 = a.split('!')[0]
e2 = b.split('!')[0]
g1 = a.split('!')[1]
g2 = b.split('!')[1]
t1 = np.array(keggDict[g1])
t2 = np.array(keggDict[g2])
if network[e1][e2]['type']==1 :
tempcc = abs(max(correlate(t1, t2)))
else :
tempcc = abs(min(correlate(t1, t2)))
if (e1, e2) not in cc_e :
cc_e[(e1, e2)]=[]
cc_e[(e1, e2)].append(tempcc)
cc = 0
for e, cclist in cc_e.iteritems() :
cc+= sum(cclist)/float(len(cclist))
netlist_cc.append(cc)
return netlist_e, netlist_eg, netlist_cc
def _setup_rank1(self, mode):
a = np.random.randn(10).astype(self.dt)
a += 1j * np.random.randn(10).astype(self.dt)
b = np.random.randn(8).astype(self.dt)
b += 1j * np.random.randn(8).astype(self.dt)
y_r = (correlate(a.real, b.real, mode=mode, old_behavior=False) +
correlate(a.imag, b.imag, mode=mode, old_behavior=False)).astype(self.dt)
y_r += 1j * (-correlate(a.real, b.imag, mode=mode, old_behavior=False) +
correlate(a.imag, b.real, mode=mode, old_behavior=False))
return a, b, y_r
def test_rank3(self):
a = np.random.randn(10, 8, 6).astype(self.dt)
a += 1j * np.random.randn(10, 8, 6).astype(self.dt)
b = np.random.randn(8, 6, 4).astype(self.dt)
b += 1j * np.random.randn(8, 6, 4).astype(self.dt)
y_r = (correlate(a.real, b.real) + correlate(a.imag, b.imag)).astype(self.dt)
y_r += 1j * (-correlate(a.real, b.imag) + correlate(a.imag, b.real))
y = correlate(a, b, "full")
assert_array_almost_equal(y, y_r, decimal=self.decimal - 1)
self.assertTrue(y.dtype == self.dt)
def test_rank3_old(self):
a = np.random.randn(10, 8, 6).astype(self.dt)
a += 1j * np.random.randn(10, 8, 6).astype(self.dt)
b = np.random.randn(8, 6, 4).astype(self.dt)
b += 1j * np.random.randn(8, 6, 4).astype(self.dt)
y_r = (correlate(a.real, b.real, old_behavior=False)
+ correlate(a.imag, b.imag, old_behavior=False)).astype(self.dt)
y_r += 1j * (-correlate(a.real, b.imag, old_behavior=False) +
correlate(a.imag, b.real, old_behavior=False))
y = correlate(b, a.conj(), 'full')
assert_array_almost_equal(y, y_r, decimal=4)
self.failUnless(y.dtype == self.dt)
def test_xcorr_xcorrt(self):
N = 1001
data1 = np.sin(np.arange(N // 2 + 1) / 100.)
data2 = np.e ** (-(np.arange(N) - 500) ** 2 / 100.) - np.e ** (-(np.arange(N) - 50) ** 2 / 100.) + 5 * np.e ** (-(np.arange(N) - 950) ** 2 / 100.)
cor1 = correlate(data1 - np.mean(data1), data2 - np.mean(data2), 'full')
cor2 = xcorrt(data2, data1, 750, window=N, ndat2d=N // 2 + 1)[::-1]
cor3 = xcorrt(data1, data2, 750, window=N, ndat1d=N // 2 + 1) #@UnusedVariable
cor3b = xcorrt(data1, data2, 750, window=0) #@UnusedVariable
cor3c = xcorrt(data2, data1, 750, window=0)[::-1] #@UnusedVariable
cor1 *= max(cor2) / max(cor1)
cor4 = correlate(data2, data1, 'full')
cor5 = xcorrt(data2, data1, 750, demean=False)
cor5b = xcorrt(data2, data1, 750, shift_zero= -100, demean=False)
cor5c = xcorrt(data2, data1, 750, shift_zero=100, demean=False)
cor4 *= max(cor5) / max(cor4)
cor7 = correlate(data1, data2, 'full')
cor8 = xcorrt(data1, data2, 750, demean=False, normalize=False)
cor10 = xcorrt(data1, data2, 750, oneside=True, demean=False, normalize=False) #@UnusedVariable
# from pylab import plot, show, subplot, legend
# subplot(411)
# plot(data1)
# plot(data2)
# subplot(412)
# plot(cor1, label='scipy.signal all demeaned and normalized')
# plot(cor2, label='xcorrt ndat1 > ndat2 ndatxd')
# plot(cor3, label='xcorrt ndat1 < ndat2 ndatxd')
# plot(cor3b, label='xcorrt ndat1 > ndat2 window = 0')
# plot(cor3c, label='xcorrt ndat1 < ndat2 window = 0')
# legend()
# subplot(413)
# plot(cor4, label='scipy.signal all normalized')
# plot(cor5, label='xcorrt')
# plot(cor5b, label='xcorrt shifted -100')
# plot(cor5c, label='xcorrt shifted 100')
# legend()
# subplot(414)
# plot(cor7, label='scipy.signal')
# plot(cor8, label='xcorrt')
# plot(cor10, label='xcorrt oneside=True')
# legend()
# show()
np.testing.assert_array_almost_equal(cor1, cor2)
np.testing.assert_array_almost_equal(cor4, cor5)
np.testing.assert_array_almost_equal(cor7, cor8)
np.testing.assert_array_almost_equal(cor5[200:300], cor5b[100:200])
np.testing.assert_array_almost_equal(cor5[200:300], cor5c[300:400])
def detect_sync(r, i, sync, sync_bits, fs=48000, baud=300, plot=False):
Ns = fs/baud
corr_r = abs(signal.correlate(r.ravel(), sync.real.ravel(),"same"))
corr_i = abs(signal.correlate(i.ravel(), sync.imag.ravel(),"same"))
corr_index = np.argmax(corr_r)-sync_bits/2*Ns
if plot:
print np.max(np.abs(corr_r))
print np.max(np.abs(corr_i))
fig = plt.figure(figsize = (16,4))
plt.plot(corr_r)
plt.plot(corr_i)
plt.title("Correlation of signal with known prefix")
return corr_index
def altPhase(self, debug=False):
"""
Alternate version of lag detection using scipy's cross correlation function.
"""
if debug or self._debug: print "altPhase..."
# normalize arrays
mod = self.model
mod -= self.model.mean()
mod /= mod.std()
obs = self.observed
obs -= self.observed.mean()
obs /= obs.std()
if debug or self._debug: print "...get cross correlation and find number of timesteps of shift..."
xcorr = correlate(mod, obs)
samples = np.arange(1 - self.length, self.length)
time_shift = samples[xcorr.argmax()]
# find number of minutes in time shift
try: #Fix for Drifter's data
step_sec = self.step.seconds
except AttributeError:
step_sec = self.step * 24.0 * 60.0 * 60.0 # converts matlabtime (in days) to seconds
lag = time_shift * step_sec / 60
if debug or self._debug: print "...altPhase done."
return lag
def maxccf(A,B):
nsamples=len(A)
xcorr = correlate(A, B)
et = np.arange(1-nsamples, nsamples)
recovered_time_shift = et[xcorr.argmax()]
#print recovered_time_shift
return recovered_time_shift
def leakage(length,periods,fnc=None,notitle=True):
import numpy as np
from scipy.signal import correlate
from scipy.fftpack import fftfreq,fft
n = int(1e7)
x = np.sin(np.linspace(0,2*periods*np.pi,length))
if callable(fnc):
x *= fnc(length)
name = fnc.__name__
else: name = 'rectangular'
f = fftfreq(int(n),1./length)
dB = lambda x:10*np.log10(x/x.max())
psd = lambda x,n: np.abs(fft(correlate(x,x,'full'),n=int(n)) )
positive = lambda x,f:x[f>0]
integers = lambda x,f:x[(np.ceil(f)-f<1e-4)&(f>0)]
def plt(ax):
ax.plot (positive(f,f)-periods, positive(dB(psd(x,n)),f))
ax.plot (integers(f,f)-periods, integers(dB(psd(x,n)),f),'ro')
(fg,ax),dumy = fig( plt, show=False )
if not notitle: ax.set_title('Spectral leakage (%s window, %d samples)'%(name,length))
ax.set_xlabel('DFT bins')
ax.set_ylabel('Relative Magnitude [dB]')
ax.set_xlim((-periods,14-periods))
ax.set_ylim((-70,1))
ax.set_xticks(range(-periods,14-periods+1,1))
fg.show()
def intAC(eFieldSVEA): ''' Compuite the optical autocorrelation trace ''' AC = signal.correlate(eFieldSVEA, eFieldSVEA, mode='same') return AC
def match_orders(orders, s_list_src, s_list_dst):
"""
try to math orders of src and dst
"""
center_indx = int(len(s_list_src) / 2)
center_s = s_list_src[center_indx]
from scipy.signal import correlate
# TODO : it is not clear if this is a right algorithm
# we have to clip the spectra so that the correlation is not
# sensitive to bright lines in the target spectra.
s_list_dst_clip = [np.clip(s, -10, 100) for s in s_list_dst]
cor_list = [correlate(center_s, s, mode="same") for s in s_list_dst_clip]
cor_max_list = [np.nanmax(cor) for cor in cor_list]
center_indx_dst = np.nanargmax(cor_max_list)
delta_indx = center_indx - center_indx_dst
print cor_max_list, delta_indx
orders_dst = np.arange(len(s_list_dst)) - center_indx_dst + orders[center_indx]
return delta_indx, orders_dst
def freq_from_autocorr(signal, fs):
"""
Estimate frequency using autocorrelation
Pros: Best method for finding the true fundamental of any repeating wave,
even with strong harmonics or completely missing fundamental
Cons: Not as accurate, doesn't find fundamental for inharmonic things like
musical instruments, this implementation has trouble with finding the true
peak
"""
signal = asarray(signal) + 0.0
# Calculate autocorrelation, and throw away the negative lags
signal -= mean(signal) # Remove DC offset
corr = correlate(signal, signal, mode='full')
corr = corr[len(corr)//2:]
# Find the first valley in the autocorrelation
d = diff(corr)
start = find(d > 0)[0]
# Find the next peak after the low point (other than 0 lag). This bit is
# not reliable for long signals, due to the desired peak occurring between
# samples, and other peaks appearing higher.
i_peak = argmax(corr[start:]) + start
i_interp = parabolic(corr, i_peak)[0]
return fs / i_interp
def fbcorr(arr_in, arr_fb, arr_out=None, stride=DEFAULT_STRIDE):
"""XXX: docstring"""
# -- Temporary constraints
# XXX: make fbcorr n-dimensional
assert arr_in.ndim == 3
assert arr_fb.ndim == 4
# -- check arguments
assert arr_in.dtype == arr_fb.dtype
inh, inw, ind = arr_in.shape
fbh, fbw, fbd, fbn = arr_fb.shape
out_shape = (inh - fbh + 1), (inw - fbw + 1), fbn
# -- Create output array if necessary
if arr_out is None:
arr_out = np.empty(out_shape, dtype=arr_in.dtype)
assert arr_out.dtype == arr_in.dtype
assert arr_out.shape == out_shape
# -- Correlate !
for di in xrange(fbn):
filt = arr_fb[..., di]
arr_out[..., di] = correlate(arr_in, filt, mode='valid')
return arr_out
def autoCorrLen(data): """ Calculates the autocorrelation length. Starting from 0 lag (each lag is scaled by 1/(N-lag), N being length of data array), this finds where the autocorrelation scaled by zero-lag autocorrelation drops to 0.01 first. parameters: data - 1-D array of numbers return: autoLen - autocorrelation length corr - autocorrelation note: later I want to instead implement a linear fit in log space to find the exponential scale factor then use that to solve for the lag which the amplitude drops to 0.01 instead i.e. autocorrLen = - scale ln(0.01) where scale is the -1/slope of the fit """ arg = data - data.mean() # calculate the autocorrelation and lag array corr = sig.correlate(arg,arg) center = np.floor(len(corr)/2)+1 # find center index corr = corr[center:len(corr)]/corr[center] # restrict to positive lag where = np.where(corr<0.01) # find where autocorr equals autoLen = float(where[0][0]) # normalize by length of array return [autoLen, corr]
def align_adc_w_nrz(ADC, NRZ, OSR,
nrz_start=1e3, corr_len=250):
'''to align and downsampling of ADC by NRZ'''
ADC = ADC.reshape(-1, OSR, order='C')
r = int(nrz_start) + numpy.arange(0, corr_len, dtype='int').reshape(-1, 1)
delay = numpy.zeros(OSR, dtype='int')
delay_corr = numpy.zeros(OSR)
delay_corr_full = numpy.zeros((len(r), OSR))
for i in numpy.arange(0, OSR, dtype='int'):
delay[i], delay_corr[i] = fun.find_corr_shift(NRZ[r, 0], ADC[r, i])
delay_corr_full[:, i] = signal.correlate(
NRZ[r, 0], ADC[r, i], mode='same').ravel()
delay_corr_full = delay_corr_full.reshape((-1, 1))
t = fun.range_len_central_zero(
numpy.size(delay_corr_full)
).reshape(-1, 1) / OSR
# figure(2)
# clf()
# plot (t,delay_corr_full[:,0])
m = numpy.argmax(delay_corr)
d = delay[m]
# print d
X = numpy.roll(ADC[:, m], d)
X = X.reshape((1, numpy.size(X)))
return X
def get_align_indices(self, wave):
#wave = helpers.blur_image(wave.astype('float'),1)
wave = sn.uniform_filter(wave.astype('float'), (3,3))
indices = []
w_base = wave.mean(axis=0)
w_base_n = (w_base-w_base.min())/(w_base.max()-w_base.min())
pad_left = n.ones(wave.shape[1]/2.)*w_base_n[0:10].mean()
pad_right = n.ones(wave.shape[1]/2.)*w_base_n[-10:].mean()
ww0=n.hstack((pad_left,w_base_n,pad_right))
flatten = 3
for i in range(wave.shape[0]):
if 0:
indices.append(0)
else:
ww = wave[max(0,i-flatten):min(wave.shape[0], i+flatten)]
w_i = ww.mean(axis=0)
w_i2 = helpers.smooth(wave[i])
w_i = helpers.smooth(w_i)
w_i_n = (w_i-w_i.min())/(w_i.max()-w_i.min())
w_i_n2 = (w_i2-w_i2.min())/(w_i2.max()-w_i2.min())
cc = ss.correlate(ww0, w_i_n, mode='valid')
indices.append(cc.argmax()-wave.shape[1]/2.)
#make a nice polynomial fit for the indices
indices = n.array(indices).astype('int')
return indices
def altPhase(self, debug=False):
'''
Alternate version of lag detection using scipy's cross correlation
function.
'''
if debug or self._debug: print "altPhase..."
# normalize arrays
mod = self.model
mod -= self.model.mean()
mod /= mod.std()
obs = self.observed
obs -= self.observed.mean()
obs /= obs.std()
if debug or self._debug: print "...get cross correlation and find number of timesteps of shift..."
xcorr = correlate(mod, obs)
samples = np.arange(1 - self.length, self.length)
time_shift = samples[xcorr.argmax()]
# find number of minutes in time shift
step_sec = self.step.seconds
lag = time_shift * step_sec / 60
if debug or self._debug: print "...altPhase done."
return lag
def cross_correlate(profiles, template, period, resample_factor=100):
"""Template matching function. Cross-correlate profiles with a template,
and determine the lag (is seconds).
Input:
profiles: profiles in the channels
template: template to use for cross-correlation
period: pulse period (s)
resample_factor: factor to use fp resampling the correlation functions
"""
resolution = len(profiles[0])
time_resolution = period/float(resolution)
delay = np.zeros(np.shape(profiles)[0])
for i in range(np.shape(profiles)[0]):
correlation_coefficients = correlate(template, profiles[i])
resampled_coeffiecients = resample(correlation_coefficients, resample_factor \
* len(correlation_coefficients))
lag = np.argmax(resampled_coeffiecients) / float(resample_factor)
lag = np.mod(lag, resolution) + 1.0 # scipy correlate return N + 1 points
# Restrict the lag from shifting profiles across full period
if lag > len(template)/2.:
lag = len(template) - lag
else:
lag = -lag
delay[i] = time_resolution * lag
return delay
def corrfunc(x, y, t):
''' Caluclate the cross correlation function and timeshifts for a
pair of time series x,y
'''
# normalize input series
x -= x.mean()
y -= y.mean()
x /= x.std()
y /= y.std()
# calculate cross-correlation function
corr = signal.correlate(x,y)/float(len(x))
# transform time axis in offset units
lags = np.arange(corr.size) - (t.size - 1)
tstep = (t[-1] - t[0])/float(t.size)
offset = lags*tstep
# time shift is found for the maximum of the correlation function
shift = offset[np.argmax(corr)]
# new time axis to plot shifted time series
newt = t + shift
# correct time intervals if shift bigger than half the interval
if min(newt) > (max(t)/2):
newt = newt - max(t)
shift = shift - max(t)
elif max(newt) < (min(t)/2):
newt = newt + min(t)
shift = shift + min(t)
return corr, offset, newt, shift
def cross_correlate(SNR=10.0):
wave,spec = read_spectrum()
wave_resamp, spec_resamp = bin_spectrum(wave,spec)
#With noise
wave_resamp, noisy_spec = add_noise(wave_resamp, spec_resamp, SNR=SNR)
flat_spec_noise = flatten_spec(noisy_spec)
wave_logspace_noise, flat_spec_log_noise = regrid_spectrum(wave_resamp, flat_spec_noise)
#Without noise
flat_spec_no_noise = flatten_spec(spec_resamp)
wave_logspace_no_noise, flat_spec_log = regrid_spectrum(wave_resamp,flat_spec_no_noise)
#Plot with noise and without noise, both flattened and regridded into logspace
plt.ion()
plt.figure(1)
plt.clf()
plt.plot(wave_logspace_noise,flat_spec_log_noise)
plt.plot(wave_logspace_no_noise,flat_spec_log)
#Cross correlate
#(Need to check if this is the right order for np.correlate)
cor = correlate(flat_spec_log_noise,flat_spec_log, mode='full' )
plt.ion()
plt.figure(2)
plt.clf()
plt.plot(cor)
#Cross correlate with velocity on x-axis
#delta_lnwave = np.log(wave_logspace_noise)
#take median of difference and convert to meters from angstroms
#diff = np.median((np.diff(delta_lnwave)))/(1e10)
# set value speed light in m/s
c = 2.99792458e8
dv=(((wave_logspace_noise[1]-wave_logspace_noise[0])/(wave_logspace_noise[0]))*c)
# recenter cor
l = len(cor)
ran = np.array(range(l))
n_init = ((l-1)/2.0)
n_fin = ran - n_init
#creates graph with peak centered at 0
plt.ion()
plt.figure(4)
plt.clf()
plt.plot(n_fin, cor)
#error here, says operands could not be broadcast together with shapes (328,) (657,)
n_arr = np.array(n_fin)
v = (dv * n_arr)/1000.
plt.ion()
plt.figure(3)
plt.clf()
plt.plot(v, cor, 'o')
plt.plot(v,cor)
plt.xlabel('Velocity km/s')
plt.ylabel('Correlation Amplitude')
return
def find_corr_shift (a,b):
'''d: return value
a = np.roll(b,d)'''
t = range_len_central_zero(len(a))
C = signal.correlate(a,b,mode='same')
p = np.argmax(C)
return (t[p],C[p])
def local_mean(img, size=3):
""" Compute a image of the local average
"""
structure_element = np.ones((size, size), dtype=img.dtype)
l_mean = signal.correlate(img, structure_element, mode='same')
l_mean /= size**2
return l_mean
def is_periodic(aud_sample, SAMPLING_RATE = 8000):
'''
:param aud_sample: Numpy 1D array rep of audio sample
:param SAMPLING_RATE: Used to focus on human speech freq range
:return: True if periodic, False if aperiodic
'''
# TODO: Find a sensible threshold
thresh = 1e-1
# Use auto-correlation to find if there is enough periodicity in [50-400] Hz range
values = signal.correlate(aud_sample, aud_sample, mode='full')
# values = values[values.size/2:]
# print(values.max, values.shape)
# [50-400 Hz] corresponds to [2.5-20] ms OR [20-160] samples for 8 KHz sampling rate
l_idx = int(SAMPLING_RATE*2.5/1000)
r_idx = int(SAMPLING_RATE*20/1000)
subset_values = values[l_idx:r_idx]
# print(subset_values.shape, np.argmax(subset_values), subset_values.max())
if subset_values.max() < thresh:
return False
else:
return True
def local_var(img, size=3):
""" Compute a image of the local variance
"""
structure_element = np.ones((size, size), dtype=img.dtype)
l_var = signal.correlate(img**2, structure_element, mode='same')
l_var /= size**2
l_var -= local_mean(img, size=size)**2
return l_var
def computeBias(self, fasta, chromDict, pwm):
"""compute bias track based on sequence and pwm"""
self.slop(chromDict, up = pwm.up, down = pwm.down)
sequence = seq.get_sequence(self, fasta)
seqmat = seq.seq_to_mat(sequence, pwm.nucleotides)
self.vals = signal.correlate(seqmat,np.log(pwm.mat),mode='valid')[0]
self.start += pwm.up
self.end -= pwm.down
def acorrt(a, num):
"""
Return not normalized auto-correlation of signal a.
Sample 0 corresponds to zero lag time. Auto-correlation will consist of
num samples.
"""
return correlate(add_zeros(a, num, 'right'), a, 'valid')
# # 데이터 구성 image = RandomState(0).choice(np.arange(0, 4), size=25).reshape(5, 5) # array([[0, 3, 1, 0, 3], # [3, 3, 3, 1, 3], # [1, 2, 0, 3, 2], # [0, 0, 0, 2, 1], # [2, 3, 3, 2, 0]]) filter = RandomState(0).choice(np.arange(3), size=9).reshape(-1, 3) # array([[0, 1, 0], # [1, 1, 2], # [0, 2, 0]]) # 교차 상관 ccor = correlate(image, filter) # array([[ 0, 0, 6, 2, 0, 6, 0], # [ 0, 12, 11, 10, 9, 9, 3], # [ 6, 11, 19, 9, 16, 11, 3], # [ 2, 8, 6, 11, 12, 10, 2], # [ 0, 5, 8, 10, 11, 5, 1], # [ 4, 8, 11, 10, 7, 3, 0], # [ 0, 2, 3, 3, 2, 0, 0]]) ccor_valid = correlate(image, filter, 'valid') # array([[19, 9, 16], # [ 6, 11, 12], # [ 8, 10, 11]]) stride = 1 filter_size = 3
image.imsave(os.path.join(PATH_TO_RELU, '{}.png'.format(i)),
conv1,
cmap=CMAP,
vmin=0,
vmax=255)
################################################################################
# PrimaryCaps
################################################################################
primary_caps_output = np.empty((6, 6, 256))
for i in range(primary_caps_weights.shape[3]):
# Get the 9x9x256 kernel
extracted_filter = primary_caps_weights[:, :, :, i]
# Apply convolution
conv2 = signal.correlate(conv1_output, extracted_filter, 'valid')
conv2 = conv2 + primary_caps_bias[i]
# Outputs 12x12, but we need 6x6 so we drop every other item
conv2 = conv2[::2, ::2, :]
conv2 = np.squeeze(conv2)
# ReLU
conv2 = np.maximum(0, conv2)
primary_caps_output[:, :, i] = conv2
# The paper says that a PrimaryCaps layer is a 6x6 matrix of 8 dimensional
# vectors and there should be 32 PrimaryCaps layers. Meaning we have 6x6x32 vectors
# which equals 1,152 vectors.
# We only really need a list of all the 8d vectors hence we can reshape the matrix
# to: (1152, 8, 1)
f = ut.freq_fr_time(t) # frequency axis
tc = ut.corr_fr_time(t) # correlation time axis
cd = prn.gold_seq(3, 5, no_periods=3) # code
Ts = 10e-3 # Nyquist's symbol interval
tau = 0.8 # time acceleration factor
Tstr = Ts * tau # transmitted symbol interval
td = 0.05 # initial delay of the sequence (time offset)
# Time Domain
a1 = gen.rcos_tr(t, Tstr, td + Tstr / 2, cd, Ts, 1.0)
a2 = gen.rcos_tr(t, Tstr, td + Tstr / 2, cd, Ts, 0.5)
a3 = gen.rcos_tr(t, Tstr, td + Tstr / 2, cd, Ts, 0.0)
c = gen.rect_tr(t, Tstr, 0, td, cd)
# Correlate processor
A1_c = signal.correlate(a1, a1, 'full')
A2_c = signal.correlate(a2, a2, 'full')
A3_c = signal.correlate(a3, a3, 'full')
C1_c = signal.correlate(c, a1, 'full')
C2_c = signal.correlate(c, a2, 'full')
C3_c = signal.correlate(c, a3, 'full')
CC_c = signal.correlate(c, c, 'full')
##################### Plots ###########################
plt.figure(1, figsize=(10, 15), dpi=300)
# Time domain
ax1 = plt.subplot(311)
plt.plot(t, a1, '-r', label='$x_{rcos}(t), \\beta = 1.0$')
def accumulated_correlation(signals,
dt,
coordinates,
x_lims,
y_lims,
z_lims,
v_p,
grid_size=10):
"""
Estimate the location of an acoustic event from multiple microphone signals
The Accumulated Correlation algorithm estimates the source location of a
signal that arrives at different times at multiple sensors. It starts by
calculating the cross-correlation for each pair of microphones signals. For
each test grid point, the expected time delay is calculated for each
microphone. Then for each unique signal pair the difference in the expected
time delay is used as an index into the cross correlation vectors. The
value in the cross correlation vector is added to a running sum for the
current test grid point. Finally, the test grid point with the largest sum
is taken as the most likely source location of the signal.
Parameters
----------
signals : numpy.ndarray
An array of time-domain signals
dt : scalar
The amount of time between each signal sample
coordinates: numpy.ndarray
An array of microphone coordinates (2D array with dimensions N x 2)
x_lims: numpy.array
The x-axis limits of the search grid
y_lims: numpy.array
The y-axis limits of the search grid
z_lims: numpy.array
The z-axis limits of the search grid
v_p: scalar
The speed of sound in the cavity material
grid_size: int, optional
The number of vertical and horizontal test points (default 10)
Returns
-------
c : list
A two-element list containing the x and y coordinates
"""
# The cross-correlation takes O(n) time, where n is the length of the signals
# These loops take O(N^2) time, where N is the number of signals
# For constant N, then, increasing the signal size linearly increases the
# running time
#
# - Calculate the lag matrix (skip auto correlations since they aren't used)
lag_matrix = np.zeros(
(len(signals), len(signals), len(signals[0]) * 2 - 1))
for i, signal_i in enumerate(signals):
for j, signal_j in enumerate(signals[i + 1:]):
lag_matrix[i, j + i + 1] = sig.correlate(signal_i, signal_j)
lag_matrix[j + i + 1, i] = lag_matrix[i, j + i + 1]
# - Create a zero matrix the size of the test point grid (sum matrix)
sums = np.zeros((grid_size, grid_size, grid_size))
xs = np.linspace(x_lims[0], x_lims[1], num=grid_size)
ys = np.linspace(y_lims[0], y_lims[1], num=grid_size)
zs = np.linspace(z_lims[0], z_lims[1], num=grid_size)
# The math in the inner loop takes O(1) time
# The inner two loops take O(N^2) time
# The outer two loops take O(M^2) time if we assume equal sized horizontal
# and vertical grids with M rows and columns
# Together this is O(M^2*N^2) time
#
# - For each test point...
for a, x in enumerate(xs):
for b, y in enumerate(ys):
for c, z in enumerate(zs):
# - For each pair of microphones...
for i, signal_i in enumerate(signals):
for j, signal_j in enumerate(signals[i + 1:]):
# - Calculate the expected difference in TOA
xi = coordinates[i, 0]
yi = coordinates[i, 1]
zi = coordinates[i, 2]
dxi = xi - x
dyi = yi - y
dzi = zi - z
di = math.sqrt(dxi * dxi + dyi * dyi + dzi * dzi)
ti = di / v_p
# Note: j -> j+i+1 because of the loop optimization
xj = coordinates[j + i + 1, 0]
yj = coordinates[j + i + 1, 1]
zj = coordinates[j + i + 1, 2]
dxj = xj - x
dyj = yj - y
dzj = zj - z
dj = math.sqrt(dxj * dxj + dyj * dyj + dzj * dzj)
tj = dj / v_p
tij = tj - ti
n0 = len(signals[0])
k = int(round(n0 - tij / dt - 1))
# - Add the appropriate lag matrix value for the given TOA delta to the
# sum matrix
sums[a, b, c] += lag_matrix[i, j + i + 1, k]
# - Use the max sum matrix element to calculate the most likely source point
max_indicies = np.unravel_index([np.argmax(sums)], np.shape(sums))
return [
xs[max_indicies[0][0]], ys[max_indicies[1][0]], zs[max_indicies[2][0]]
]
fa = np.arange(400000, 120000 - 1, -20000)
scales = np.array(float(c)) * fs / np.array(fa)
[cfs1, frequencies1] = pywt.cwt(datay1, scales, wavelet, dt)
[cfs2, frequencies2] = pywt.cwt(datay2, scales, wavelet, dt)
magnitude1 = (abs(cfs1))**2
magnitude2 = (abs(cfs2))**2
corr_show = []
for i in range(len(magnitude1)):
mean1 = magnitude1[i].mean()
magnitude1[i] = magnitude1[i] / mean1
mean2 = magnitude2[i].mean()
magnitude2[i] = magnitude2[i] / mean2
temp = signal.correlate(magnitude1[i],
magnitude2[i],
mode='same',
method='fft')
meanc = temp.mean()
corr_show.append(temp / meanc)
##corr = np.array(corr)
##
##E=207 * pow(10,9) #203#207
##p=7.86 * 1000 #7.93#7.86
##o=0.27
##h=0.002
##
##param = E * h * h * pi * pi / 3.0 / p / (1.0 - o * o)
##c = pow(param * pow(freq,2),0.25)
##time = sgn * (100.0 - dd) * 2.0 / 100.0 / c * 1000.0 / 1.5
##
QuadDemod = QuadDemod * np.real(signal.hilbert(
QuadDemod)) #RcvSignal[RcvStartingSample:-int(nBitSample)]
InphaseEnvelop = butter_lowpass_filter(
InphaseDemod, 3 * pow(10, 3), fs, 4) / InphaseDemod.size
QuadEnvelop = butter_lowpass_filter(QuadDemod, 3 * pow(10, 3), fs,
4) / QuadDemod.size
'''
print("o Envelope size")
print("- In-phase: ", InphaseEnvelop.size)
print("- Quadrature: ", QuadEnvelop.size)
print("")
'''
# Correlation
InphaseCorrelation = signal.correlate(
InphaseEnvelop, SymbolSequence[(0, slice(None))], mode='valid')
QuadCorrelation = signal.correlate(QuadEnvelop,
SymbolSequence[(1,
slice(None))],
mode='valid')
Correlation = (InphaseCorrelation + QuadCorrelation)
#Correlation = Correlation / Correlation.size
tCorrelation = np.arange(RcvStartingSample, \
(RcvStartingSample+Correlation.size) , 1) * Ts * 1000 # in ms
CorrelationPeak = np.argmax(Correlation)
Estimation = (RcvStartingSample +
CorrelationPeak) * Ts * 340 / 2 - 0.05
if abs(Estimation - Distance > 0.2):
def get_audio(plot_debug=False):
""" Called by
:param: plot_debug, if True do a debug plots
:return: None
Acquire Data under a trigger mode, then save the Data to the HD.
Get Constants from Constants.py
Variables will be extracted from the Variables_dict who is managed by Disk_IO.
When debug==True plot acquired data as diagnostic.
"""
recall_pickled_dict(
) # Load variables from the c.s.v. c.pickle_txt_fullpath
SamplingFreq = v.SamplingFreq # Sampling Frequency, Hz
TrigLevel = v.TrigLevel # Actual Trigger level as a %
AveragesRequired = v.AveragesRequired # Required Averages number
Length = v.Length # Pile length
Speed = v.Speed # P wave speed in concrete
T_echo_0 = 2 * Length / Speed # Return time of echo_0
indx_echo_0 = round(T_echo_0 *
SamplingFreq) # Index of the 1.st echo_0 sample
#
save_actual_pid() # Save the PID to a file, for successive kill
#
""" Called at each new Acquisition, remove files at c.temp_data_path, if the dir was removed, recreate it.
"""
create_and_clear(c.temp_data_path, delete_files=True)
#
TrigLevel_32 = (
TrigLevel / 100
) * c.full_scale_32 # From % to fraction of unity, to fract. of c.full_scale_32
pk_foot = 1 / 100 # Relative factor for the pulse pedestal
FORMAT = pyaudio.paInt32 # Signed 32 bit (Little Endian byte order)
CHANNELS = int(2)
byte_width = 4 # Bytes in one signed 32 bit sample
#
print()
print("=" * 50)
print(" Started '" + __file__ + "' as a separate executable")
print("=" * 50)
if c.IS_RASPBERRY: print("Machine is Raspberry Pi")
else: print("Machine is not a Raspberry Pi")
print("Audio device is:", c.SOUND_DEVICE)
""" New error handler: suppress all libasound.so error messages, by substitution of the error handler.
"""
ERROR_HANDLER_FUNC = CFUNCTYPE(None, c_char_p, c_int, c_char_p, c_int,
c_char_p)
def py_error_handler(filename, line, function, err, fmt):
print('.',
end="") # Print a single '.' point instead of the error message
# #
#
c_error_handler = ERROR_HANDLER_FUNC(py_error_handler)
asound = cdll.LoadLibrary('libasound.so')
#
# Set error handler
asound.snd_lib_error_set_handler(c_error_handler)
#
# Initialize PyAudio
p = pyaudio.PyAudio()
p.terminate()
print()
#
#--------------------------- Error handler end ----------------------------------
""" Creates an instance of the PyAudio class , and open a stream to write output frames
"""
paudio = pyaudio.PyAudio()
stream = paudio.open(rate=SamplingFreq,
channels=CHANNELS,
format=FORMAT,
input=True,
input_device_index=c.SOUND_DEVICE,
frames_per_buffer=c.N_FRAMES)
#
i = 1
while i <= int(AveragesRequired):
"""
Wait until the Trigger level is reached getting frames continuously,
the format is long i.e. int32; the AD has 24 bit, 8 MSBits are zeros.
The Trigger Channel is Ch1: Odd samples: 1, 3, 5,... => Ch1
The variable inp_short_buffer cannot be predefined as a bytearray (that is mutable)
because stream.read() return an array of bytes (that is immutable).
"""
inp_old_buffer = np.zeros(CHANNELS * c.N_FRAMES, dtype=np.int32)
inp_big_buffer = np.zeros(CHANNELS * c.N_FRAMES * c.N_BLOCKS,
dtype=np.int32)
beg = 0
end = CHANNELS * c.N_FRAMES
os.system("sync") # To empty write queue
#
# ====================== Trigger loop Begin ======================\
#
print("\n" + "=o" * 25 + "=")
if do_plot: time.sleep(2) # For testing, wait to close the plot window
else: time.sleep(1)
print("Waiting for Trigger n.", i, "...")
while True:
inp_short_buffer = np.frombuffer(stream.read(c.N_FRAMES), np.int32)
# #
""" From the array of bytes inp_short_buffer of int32: ch1, ch2, c1, ch2,... blocks
of interleaved 4 bytes get the tuple ch1_int32 discarding each successive 4 bytes
represented by xxxx (corresponding to ch2, i.e. get only ch1 values), for a total of c.n_frames.
"""
if len(inp_short_buffer) != c.N_FRAMES * CHANNELS: continue
ch1_int32 = unpack(
'ixxxx' * c.N_FRAMES, inp_short_buffer
) # Get tuple (i32 ch1 only) from tuple of bytes
ch1_arr_32 = np.array(ch1_int32) # From tuple to np array
pk1_32 = np.max(
np.abs(ch1_arr_32)) # Get absolute peak value of ch1 as int32
if pk1_32 < TrigLevel_32: # No Trigger
inp_old_buffer = inp_short_buffer # No Trigger, save as a possible pre-trigger
continue
else: # Get Trigger
""" The following print is only for testing: must been leaved commented.
Represents values of the trigger frame.
"""
# rms1_32 = np.std(ch1_arr_32) # Check for single or few noise spike on ch1
# print("Trig. rms1 = {:3.1f}".format((rms1_32 / c.full_scale_32)*1000), "mV")
# print("Trig. pk1 = {:3.1f}".format((pk1_32 / c.full_scale_32)*1000), "mV")
inp_big_buffer[
beg:end] = inp_old_buffer # Pre-Trigger block of data
beg = end # Prepare 2.nd block address
end += CHANNELS * c.N_FRAMES # Next step into inp_big_buffer
inp_big_buffer[
beg:
end] = inp_short_buffer # Insert 2.nd block of Trigger data
break
# #
# #
# END while True:
# ======================= Trigger loop End =======================/
#
# ====================== Acquisition loop start ==================\
j = 2 # Block index: 0 and 1 blocks inserted inside the Trigger loop
while j < c.N_BLOCKS:
beg = end
end += CHANNELS * c.N_FRAMES
inp_short_buffer = np.frombuffer(stream.read(c.N_FRAMES), np.int32)
inp_big_buffer[beg:end] = inp_short_buffer # Packing blocks
j += 1
# #
# ====================== Acquisition loop end ====================/
#
""" Unpacking bytes to integers (32 bit) in the tuple tpl_i32.
Then separating interleaved Channels, Ch1, Ch2, getting c.N_of_samples points for channel.
Finally we have y1, y2 as np.arrays of float64, and scaled to +/-1 and compensated for Pisound Input Gain.
To verify the correctness of the formatting string: calcsize('ii') returns 8
"""
tpl_i32 = unpack(
'ii' * c.N_OF_SAMPLES,
inp_big_buffer) # Packed bytes and interleaved: Ch1, Ch2
y1_tpl_i32 = tpl_i32[0:c.N_OF_SAMPLES *
CHANNELS:2] # Odd: Ch1 as integer 32
y2_tpl_i32 = tpl_i32[1:c.N_OF_SAMPLES * CHANNELS +
1:2] # Even: Ch2 as integer 32
y1 = np.array(
y1_tpl_i32
) / c.full_scale_32 # Scaled to +/- 1 full scale # Go to float 8 bytes
y2 = np.array(y2_tpl_i32) / c.full_scale_32
y1 /= PI_INP_GAIN # Pisound board Input Gain compensation
y2 /= PI_INP_GAIN
#
# /\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
# PUT A PULSE ON Ch1 TO TEST GLITCH DETECTION
#
# noise_1 = np.random.rand(np.max(y1.shape)) / 500
# noise_2 = np.random.rand(np.max(y1.shape)) / 500
# y1 = noise_1
# y2 = noise_2
# y1[480] = 0.5
#
# /\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
# ========================== SATURATION CHECK BEGIN ==========================\
#
y1_Min = np.min(y1) # Getting min / max
y1_Max = np.max(y1)
y2_Min = np.min(y2)
y2_Max = np.max(y2)
max_abs1 = max(abs(y1_Min), abs(y1_Max)) # ch1 absolute peak
max_abs2 = max(abs(y2_Min), abs(y2_Max)) # ch2 absolute peak
max_abs = max(max_abs1, max_abs2) # Greater absolute maximum peak
#
if max_abs < c.satur_threshold: # Saturation check
is_Saturated = False
else:
is_Saturated = True
doBeep(on_list=alarm_3_S[0], off_list=alarm_3_S[1])
print(Saturation_msg, "max_abs =", max_abs)
# #
# ========================== SATURATION CHECK END ============================/
# ========================== GLITCH TESTING BEGIN ============================\
#
W = 1 # Range minimum width
is_err1 = False
is_err2 = False
#----------- NEW TEST BASED ON THE DIFFERENTIATION OF THE GLITCH (DIRAC DELTA FUNCTION)
y1_d = np.diff(y1)
y2_d = np.diff(y2)
indx1 = min(min(
np.nonzero(np.abs(y1) == max_abs1))) # Index of max(abs(y1))
indx2 = min(min(
np.nonzero(np.abs(y2) == max_abs2))) # Index of max(abs(y2))
if indx1 < (np.max(y1.shape) - 2) and (np.max(
abs(y1_d[indx1 - 1] - max_abs1)) < max_abs1 / 50):
is_err1 = True
# #
if indx2 < (np.max(y2.shape) - 2) and (np.max(
abs(y2_d[indx1 - 1] - max_abs1)) < max_abs2 / 50):
is_err2 = True
# #
#-------------------------------------------------------------------------------
print("")
if is_err1: print(Glitch_msg, "Ch1")
if is_err2: print(Glitch_msg, "Ch2")
if is_err1 or is_err2: # Glitches counted as saturation:
doBeep(on_list=alarm_1_S[0], off_list=alarm_1_S[1])
is_Saturated = True # the acquisition will be repeated
# #
# ============================ GLITCH TESTING END ============================/
# ======================= CHANNELS SWAP TESTING BEGIN ========================\
#
""" Sometime the first acquisition can swap ch1 with ch2, here we detect that occurrence, and in the case,
we recovery by a swap between ch1 and ch2.
1) The autocorrelations of y1 and y2 are calculated.
2) The max absolute peaks of the autocorrelations are calculated.
3) Each one of the autocorrelation amplitudes are normalized using the absolute peaks of point (2).
4) The normalized autocorrelations are rounded to 1 decimal to exclude little oscillations around 0.
5) The differentiation of the sign changements of the normalized and rounded correlations is calculated.
6) The differentiations of point (5) are cumulated to obtain the final scalar count.
7) The ch1 Force signal is a well behaved and then bandlimited pulse with only two zero crossing
(excluding noise), by contrast the ch2 Accel signal being a derivative (accelerometer signal)
has surely more sign changements, consequently when the total sign changes of ch1 exceeds that of ch2
the channels are swapped.
"""
upper = int(3 * indx_echo_0) # Upper index limit for checking
corr_y1 = correlate(y1[0:upper], y1[0:upper], mode='same')
corr_y2 = correlate(y2[0:upper], y2[0:upper], mode='same')
pk_abs_corr_1 = np.max(np.abs(corr_y1))
pk_abs_corr_2 = np.max(np.abs(corr_y2))
corr_y1 = np.round(corr_y1 / pk_abs_corr_1, 1)
corr_y2 = np.round(corr_y2 / pk_abs_corr_2, 1)
nz_diff_corr_y1 = (np.diff(np.sign(corr_y1), n=1) != 0).sum()
nz_diff_corr_y2 = (np.diff(np.sign(corr_y2), n=1) != 0).sum()
#
if nz_diff_corr_y1 < nz_diff_corr_y2:
is_swapped = False
else:
is_swapped = True
# #
if plot_debug:
print("\n" + "Zero crossing comparison:", nz_diff_corr_y1, " < ",
nz_diff_corr_y2, " ", not is_swapped)
# #
print(" Good if:")
print(" nz_diff_corr_y1 < nz_diff_corr_y2")
print("-----------------------------------")
print(" ", nz_diff_corr_y1, " | ", nz_diff_corr_y2)
print("-----------------------------------")
if is_swapped:
print("\n" + "/" * 35)
print(" ERROR: Swapped ch1, ch2")
print(" CORRECTION DONE!")
print("/" * 35 + "\n")
y1, y2 = y2, y1 # Restore from swap error
# #
# ======================== CHANNELS SWAP TESTING END =========================/
if not is_Saturated:
""" If is_Saturated returns to the external acquisition loop: while i <= int(AveragesRequired)
Preparing good data for storage:
Relocation of the start of the inputrms1_32 signal in y1, y2, to eliminate the pre-trigger
part that has a variable length. That part will be shortened as follows:
a) Search the first index where the Pulse input Data array (y1) is bigger than pk * pk_foot.
The index of that basement point will be named index_Trig.
b) The new starting index is obtained decreasing, as possible, index_Trig by a fixed amount,
in order to assure the inclusion of sufficient initial part of the signal.
The corresponding amount of time, guard_T, will be equal to the hammer
pulse width t.HAMMER_DT, the number of samples will be N_guard.
"""
y1_shape = y1.shape # Array y1 dimensions
y2_shape = y2.shape # Array y2 dimensions
if not (np.max(y1_shape) == np.max(y2_shape)): # Length comparison
print(Length_msg)
print("get_audio: y1_shape =", y1_shape)
print("get_audio: y2_shape =", y2_shape)
doBeep(on_list=bip_1_5_S[0], off_list=bip_1_5_S[1])
return
# #
# =============================== Relocation Begin =========================\
#
pk1 = pk1_32 / c.full_scale_32 # Peak scaled to +/- 1
y1_length = np.max(y1_shape) # Length of y1 array
indexes = np.array(np.nonzero(
abs(y1) > pk1 *
pk_foot))[0, :] # Array of indexes, [0,:] => from 1xN to N
print("len(indexes) =", len(indexes))
index_Trig = np.amin(
indexes) # Lowest index i.e. index pedestal start
dT = 1.0 / SamplingFreq # Sampling time
guard_T = HAMMER_DT # Safety margin time, before Pulse pedestal
N_guard = int(round(guard_T /
dT)) # Corresponding guard margin as samples
if index_Trig > N_guard: # Guard must begin after y1[0]
new_start = index_Trig - N_guard # Index (>=0) for the new starting point
tmp_array = np.zeros(
y1_length) # Temporary empty array for new y1
tmp_array[0:-1 - new_start] = copy.copy(
y1[new_start:-1]
) # Fill y1 without the guard section of y1
# leaves a tail of zeros
y1 = copy.copy(tmp_array) # y1 replaced by relocated data
tmp_array = np.zeros(np.max(
y2.shape)) # Temporary empty array for new y2
tmp_array[0:-1 - new_start] = copy.copy(
y2[new_start:-1]
) # Fill y2 without the guard section of y2
y2 = copy.copy(tmp_array) # y2 replaced
tmp_length = np.max(y1.shape) # Actual length of y1 array
if tmp_length != y1_length:
print(
"\n" +
"ERROR in get_audio: Length of y1, y2 modified erroneously"
)
# #
else: # Leave the signal unaltered
pass
# #
#=============================== Relocation End ===========================/
#
pk1 = np.max(np.abs(y1))
pk2 = np.max(np.abs(y2))
rms1 = np.std(y1)
rms2 = np.std(y2)
print("\n" + "Saving data to Disc")
print("rms1 = {:3.1f}".format(rms1 * 1000),
"mV; pk1 = {:3.1f}".format(pk1 * 1000), "mV")
print("rms2 = {:3.1f}".format(rms2 * 1000),
"mV; pk2 = {:3.1f}".format(pk2 * 1000), "mV")
""" Save data to disc
"""
name_1 = "/y1_" + str('{:02d}'.format(i))
name_2 = "/y2_" + str('{:02d}'.format(i))
path_1 = c.temp_data_path + name_1
path_2 = c.temp_data_path + name_2
#
if c.sav_mode == "npy":
""" Saving in Numpy binary file, not compressed, add extension .npy
"""
np.save(path_1, y1) # Uncompressed format
np.save(path_2, y2)
elif c.sav_mode == "npz":
""" Saving in Numpy binary file, compressed, add extension .npz
"""
np.savez_compressed(path_1, y1=y1) # Compressed format
np.savez_compressed(path_2, y2=y2)
# #
elif c.sav_mode == "mat":
""" Saving in Matlab format V.5, compressed, add automatically the extension .mat
loadmat() will return the vector in a dictionary ex:
d = scipy.io.loadmat("vector.mat)
vect = d["vect"]
vect = d1["y1"]
and with one more dimension added ("column"):
original vect.shape -> (n,), returned vect.shape -> (n, 1);
to return to the original dimension:
vect_reshaped = vect[:,0]
"""
scipy.io.savemat(path_1, {"y1": y1},
do_compression=True,
oned_as="column")
scipy.io.savemat(path_2, {"y2": y2},
do_compression=True,
oned_as="column")
# #
print("New acquired data:", name_1, name_2)
print("=o" * 25 + "=")
save_blows(c.blows_list_txt, name_1, name_2)
os.system("sync") # Delayed write causes a random delay
time.sleep(0.2) # Delays for x seconds
if plot_debug:
sel = int(15 * indx_echo_0) # was 1.5
mx1 = max(np.abs(y1[0:sel]))
mx2 = max(np.abs(y2[0:sel]))
mx = 1.1 * max(mx1, mx2)
tp = np.arange(
c.N_OF_SAMPLES) * 1.0 / SamplingFreq # Time vector
fig = plt.figure(1)
fig.set_size_inches(w=3, h=4)
fig.subplots_adjust(hspace=0.50)
plt.subplot(211)
plt.plot(tp[0:sel], y1[0:sel])
plt.title('get_audio Hammer')
plt.xlabel('Time [s]')
plt.ylabel('Force')
plt.grid(True)
plt.axis([tp[0], tp[sel], -mx, mx])
#
plt.subplot(212)
plt.plot(tp[0:sel], y2[0:sel])
plt.title('get_audio Accel')
plt.xlabel('Time [s]')
plt.ylabel('Accel')
plt.grid(True)
plt.axis([tp[0], tp[sel], -mx, mx])
#
plt.show()
time.sleep(0.1)
# END if plot_debug:
i += 1
# END if not is_Saturated):
# END while i <= int(AveragesRequired):
#
stream.stop_stream()
stream.close() # Close inp pyaudio object
paudio.terminate()
#
print("get_audio: closed input device, terminated")
# calculate delta t
win_len = 5 # 5 second window
shift_fl, shift_fr, shift_lr = [], [], []
corr_max_fl, corr_max_fr, corr_max_lr = [], [], []
for i in range(len(mox_diff_f) / 10): # update at 10 Hz
if i < win_len * 10:
continue
else:
front, left, right = [], [], []
for idx in range((i - win_len * 10) * 10, i * 10):
front.append(mox_diff_f[idx])
left.append(mox_diff_l[idx])
right.append(mox_diff_r[idx])
time = np.arange(1 - win_len * 100,
win_len * 100) * 0.01 # -(N-1)~(N-1)
corr_fl = signal.correlate(np.array(front), np.array(left))
corr_fr = signal.correlate(np.array(front), np.array(right))
corr_lr = signal.correlate(np.array(left), np.array(right))
corr_max_fl.append(corr_fl.max())
corr_max_fr.append(corr_fr.max())
corr_max_lr.append(corr_lr.max())
shift_fl.append(time[corr_fl.argmax()])
shift_fr.append(time[corr_fr.argmax()])
shift_lr.append(time[corr_lr.argmax()])
# save data
fd_out = h5py.File('./correlation.h5', 'w')
grp = fd_out.create_group("corr")
dset_max_fl = grp.create_dataset('corr_max_fl', (len(corr_max_fl), ),
dtype='f')
dset_max_fr = grp.create_dataset('corr_max_fr', (len(corr_max_fr), ),
#in differences
#VARMA(np.diff(x,axis=0),B,C)
#Note:
# * signal correlate applies same filter to all columns if kernel.shape[1]<K
# e.g. signal.correlate(x0,np.ones((3,1)),'valid')
# * if kernel.shape[1]==K, then `valid` produces a single column
# -> possible to run signal.correlate K times with different filters,
# see the following example, which replicates VAR filter
x0 = np.column_stack([np.arange(T), 2 * np.arange(T)])
B[:, :, 0] = np.ones((P, K))
B[:, :, 1] = np.ones((P, K))
B[1, 1, 1] = 0
xhat0 = VAR(x0, B)
xcorr00 = signal.correlate(x0, B[:, :, 0]) #[:,0]
xcorr01 = signal.correlate(x0, B[:, :, 1])
print(
np.all(
signal.correlate(x0, B[:, :, 0], 'valid')[:-1, 0] == xhat0[P:, 0]))
print(
np.all(
signal.correlate(x0, B[:, :, 1], 'valid')[:-1, 0] == xhat0[P:, 1]))
#import error
#from movstat import acovf, acf
from statsmodels.tsa.stattools import acovf, acf
aav = acovf(x[:, 0])
print(aav[0] == np.var(x[:, 0]))
aac = acf(x[:, 0])
spR = spR[:ds / 2 + 1] #振幅スペクトルらしい ampL = np.array([np.sqrt(c.real**2 + c.imag**2) for c in spL]) ampR = np.array([np.sqrt(c.real**2 + c.imag**2) for c in spR]) nspL = spL / ampL nspR = spR / ampR sds, = spL.shape ws = sds - 100 #C1 = nspL[:ws]np.conj(nspR[:sds]) #C2 = CCF(nspL[:sds],np.conj(nspR[:ws])) #C = CCF(spL[:ws],spR[:sds]) C1 = sig.correlate(nspR[:sds], nspL[:ws], mode="valid") C2 = sig.correlate(nspL[:sds], nspR[:ws], mode="valid") csp1 = ifft(C1) csp2 = ifft(C2) #print "ds:",sds,", ws:",ws #print "c1 max index:",C1.index(max(C1)),", max:",max(C1) #print "c2 max index:",C2.index(max(C2)),", max:",max(C2) print "csp1 max index:", np.argmax(csp1), ", max:", max(csp1) print "csp2 max index:", np.argmax(csp2), ", max:", max(csp2) # #print "c.shape:",C.shape #print "dL.shape:",dL.shape #print "spL.shape:",spL.shape plt.plot(csp1, "r") plt.plot(csp2, "b")
def jd_rot_fit2(velsfile1="Q1v.dat", velsfile2="Q4v.dat"):
#
# this version uses r as the spatial variable, not x (LSCP length)
#
import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import medfilt, correlate
rc('mathtext', default='regular')
plt.ion()
plt.clf()
if velsfile1 is None:
raise ArgumentError("Please give input file")
r0 = 8.5
theta0 = 220.0
l1, vel1 = get_xy_data(velsfile1)
l2, vel2 = get_xy_data(velsfile2)
v1_temp = new_vLSR(l1, vel1) # Apply the VLSR correction
v2_temp = new_vLSR(l2, vel2)
v1 = medfilt(v1_temp, kernel_size=5)
v2 = medfilt(v2_temp,
kernel_size=5) # Do the median filter that was done in McG07
ndat1 = len(v1)
ndat2 = len(v2)
sinl1 = abs(np.sin(l1 * np.pi / 180))
wt1 = np.array(sinl1)
sinl2 = abs(np.sin(l2 * np.pi / 180))
wt2 = np.array(sinl2)
rot1 = np.array(abs(v1) + theta0 * sinl1)
rg1 = np.array(r0 * sinl1)
rot2 = np.array(abs(v2) + theta0 * sinl2)
rg2 = np.array(r0 * sinl2)
#
# Create arrays with both datasets
# print "Creating array of length",ndat1+ndat2;
rg = np.append(rg1, rg2)
rot = np.append(rot1, rot2)
wt = np.append(wt1, wt2)
x = rg / r0
y = rot / theta0
weights = wt / np.mean(y)
# Fit the array (currently unweighted so dominated by dense sampling at high R)
pars = np.polyfit(x, y, 1)
# print pars
yfit = np.polyval(pars, x)
rotfit = yfit * theta0
#
# Create arrays of the differences from fit
fit1 = np.polyval(pars, rg1 / r0)
fit2 = np.polyval(pars, rg2 / r0)
diff1 = rot1 - fit1 * theta0
diff2 = rot2 - fit2 * theta0
#
# diff1 and diff2 are the residual velocities after subtracting the best fits
#
# now go back to longitude for equal step in x = linear dist along magic circle
# we'll just take the range x=3 to x=9.5 kpc (scaled by r0) defined by x01,x02
#
### x0=abs(l1*r0*np.pi/180.)
x0 = sinl1 * r0
# the 1st quadrant data are in the opposite order now, flip both arrays
diff0 = diff1
x1 = x0[::-1]
diff1 = diff0[::-1]
### x2=abs((360.-l2)*r0*np.pi/180.)
x2 = sinl2 * r0
### x01=np.linspace(3.,9.5,1300)
### x02=np.linspace(3.,9.5,1300)
x01 = np.linspace(3., 7.65, 930)
x02 = np.linspace(3., 7.65, 930)
y01 = np.interp(x01, x1, diff1)
y02 = np.interp(x02, x2, diff2)
#
# note the new step size is Delta-x = 6500/1300 pc = 5 pc
# Delta-x = 4800/960 pc = 5 pc
#
plt.plot(x1, diff1, 'r+', label="QI")
plt.plot(x2, diff2, 'b+', label="QIV")
plt.plot(x01, y01, 'r-', label="QI interp")
plt.plot(x02, y02, 'b-', label="QIV interp")
# plt.plot(x01,y01,'ro',label="QI interp")
# plt.plot(x02,y02,'bo',label="QIV interp")
plt.xlabel(r"$r_G \,(kpc)$")
### plt.xlabel(r"$x \,(kpc)$")
plt.ylabel(r"$\Delta \Theta \, (km\, s^{-1})$")
# plt.legend(loc=2)
### boxx=[3.,3.,9.5,9.5,3.]
boxx = [3., 3., 7.65, 7.65, 3.]
boxy = [-14.5, +14.5, +14.5, -14.5, -14.5]
plt.plot(boxx, boxy, 'k-')
plt.show()
#
z = correlate(y01, y02) / (len(y01) * np.std(y01) * np.std(y02))
z1 = correlate(y01, y01) / (len(y01) * np.var(y01))
z2 = correlate(y02, y02) / (len(y01) * np.var(y02))
# just for a test:
# z=jdccf_0pad(y01,y02)/(np.std(y01)*np.std(y02))
# z1=jdccf_0pad(y01,y01)/(np.var(y01))
# z2=jdccf_0pad(y02,y02)/(np.var(y02))
# test done
# print len(z)
zx1 = np.linspace(1, len(z), len(z))
zx2 = (zx1 - (len(z) / 2.)) * .005
plt.figure(2)
plt.plot(zx2, z, 'g-', label="ccf")
plt.plot(zx2, z1, 'r-', label="acf Q1")
plt.plot(zx2, z2, 'b-', label="acf Q4")
plt.legend(loc=1)
## plt.xlabel(r"$R \,(kpc)$")
## plt.ylabel(r"$\Delta\Theta (km\, s^{-1})$")
### plt.xlabel(r"$\Delta x \, \, \, (kpc)$")
plt.xlabel(r"$\Delta r_G \, (kpc)$")
plt.ylabel("Normalised Correlation Coefficient")
plt.minorticks_on()
vlines(0., -0.5, 1.5, linestyles='dotted', linewidth=1.2)
#hlines(0.,-3.,3.,linestyles='dotted',linewidth=1.2)
ylim(-0.5, 1.2)
xlim(-3, 3)
## plt.xlim(-3.5,3.5)
#
# the y axis is normalized to 1 for 100% correlation
# the x axis is in lag steps of 7.2 pc
#
# keep this for later, in case plots of the raw residuals vs. R are needed
# plt.plot(rg1,diff1,'r+',label="QI")
# plt.plot(rg2,diff2,'b+',label="QIV")
# plt.xlabel(r"$R \,(kpc)$")
# plt.ylabel(r"$\Delta\Theta (km\, s^{-1})$")
# plt.xlim(3.0,8.0)
# plt.ylim(-15.,15.)
# print np.mean(diff1),np.mean(diff2)
# print np.median(diff1),np.median(diff2)
# print np.std(diff1),np.std(diff2)
# plt.legend(loc=2)
# plt.show()
return z1, z2, z
std2 = ss().fit_transform(c_d[0])
corrupted_pca1 = sklearnPCA(n_components=169)
corrupted = corrupted_pca1.fit_transform(std2)
neighbors = classifier.kneighbors(corrupted)
predictions = classifier.predict(corrupted)
##PART 2.2: OPTIMAL DATA ALIGNMENT##
##Response to 2.2##
#The scipy module's signal.correlate function was used to calculate the
#cross correlation of a corrupted univariate time series with its nearest
#neighbor predicted from the classifier. The point of maximal correlation was
#determined from this cross-correlation array and used as the centering point
#to optimally align the data.
closest_n = neighbors[1][:, 0]
z = 0
alignment = np.zeros((30000, 2))
for i in range(len(closest_n)):
b_sig = c_d[0][i]
a_sig = d_c[0][closest_n[i]]
xcorr = correlate(a_sig, b_sig)
lag = abs(np.argmax(xcorr))
delay = abs(lag - len(a_sig)) #Since signal.correlate uses full cross
#correlation and len(xcorr) = 2*457 - 1
end = delay + c_d[1][i]
if end > 457:
end = 457
alignment[i] = [delay, end]
x_pad = np.pad(x, pad_width=(1, 0), mode='constant', constant_values=0)
print((convolution_1d(x_pad, w)))
x_pad = np.pad(x, pad_width=(0, 1), mode='constant', constant_values=0)
print((convolution_1d(x_pad, w)))
# scipy.signal.convole() 함수
conv = convolve(x, w, mode='valid')
print(conv)
conv_full = convolve(x, w, mode='full') # x의 모든 원소가 동일하게 연산에 기여.
print(conv_full)
conv_same = convolve(x, w, mode='same') # x의 크기와 동일한 리턴.
print(conv_same)
# scipy.signal.correlation() 함수
cross_corr = correlate(x, w, mode='valid')
print(cross_corr)
cross_corr_full = correlate(x, w, mode='full')
print(cross_corr_full)
cross_corr_same = correlate(x, w, mode='same')
print(cross_corr_same)
# scipy.signal.convolve2d(), scipy.signal.correlate2d()
# (4, 4) 2d ndarray
x = np.array([[1, 2, 3, 0], [0, 1, 2, 3], [3, 0, 1, 2], [2, 3, 0, 1]])
# (3, 3) 2d ndarray
w = np.array([[2, 0, 1], [0, 1, 2], [1, 0, 2]])
# x와 w의 교차 상관 연산(valid, full, same)
corr_2d_valid = correlate2d(x, w, mode='valid')
def get_acc_num(matrix, dictionary):
""" We take sclices of the entire character matrix read from the digits.txt file and assign to them the corresponding number. """
sizes = np.array([x[x != 0].size for x in indexer(matrix.T, 3)])
acc = 9 * ['?']
second_best_corrs = dict(
) # this dictionary contains the correlations and positions where a given 3x3 matrix had a good match
for key, val in dictionary.items():
# number of non-zero character matrix elements
non_zero = val[val != 0].size
# correlation calculation between the matrix slice and the 3x3 val matrix that is mapped to a given number
# From scipy: https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.correlate.html
# This approach is limited by the fact that the 3x3 matrix is likely to be matched in many places throughout the character file matrix.
# This is circumvented, however by making sure that the size (non-zero), as well as the correlation provide a good match.
corr = signal.correlate(matrix, val, 'valid')
holder = np.zeros(len(corr[0]), dtype=np.int8)
for i, x in enumerate((corr != non_zero)[0]):
if x:
holder[i] = corr[0][i]
# We keep track of the digigs that provide a good match, so that if we need to guess the identity of a character
# we do not have to perform this loop again!
second_best = np.where(holder == holder.max())
second_best_corrs[key] = (holder.max(),
(second_best[0] / 3).astype(int))
overlaps, indices = np.where(corr == non_zero)
if len(indices) > 0:
indices = np.array(list(map(int, indices / 3)))
for index in indices:
if sizes[index] == non_zero:
acc[index] = key
if '?' in acc: # if a number has not been properly assigned, we can use the second_best_corrs to propose values
possibilities = list()
for index in [i for i, x in enumerate(acc) if x == '?']:
closest_index = dict()
for key, val in second_best_corrs.items():
if index in val[1]:
closest_index[key] = val[0]
for replace in sorted(closest_index,
key=closest_index.get,
reverse=True):
acc[index] = replace
dummy = acc.copy()
dummy.append(' ')
possibilities.append(dummy)
possibilities = [
checksum(sublist) for sublist in possibilities
if '?' not in sublist
]
possibilities = [item for sublist in possibilities for item in sublist]
account = ''.join(possibilities)
else:
account = ''.join(checksum(acc))
return account
#corrects for wwvb offset
print(len(wwvbSignal))
#temp = wwvbSignal[0:4800:1]
wwvbSignal = wwvbSignal[5500::]
wwvbSignal = np.array(wwvbSignal)
#temp = np.array(temp)
#wwvbSignal = np.concatenate((wwvbSignal, temp))
print(len(wwvbSignal))
#One min wwvb
bitStream = ""
devList = []
for i in range(59):
start = i * 44100
end = (i * 44100) + 44100
corrZero = signal.correlate(wwvbSignal[start:end], Zero, mode='full')
corrOne = signal.correlate(wwvbSignal[start:end], One, mode='full')
corrX = signal.correlate(wwvbSignal[start:end], X, mode='full')
numZero = int(max(corrZero[44078:44123:1]) / 1000000000)
numOne = int(max(corrOne[44078:44123:1]) / 1000000000)
numX = int(max(corrX[44078:44123:1]) / 1000000000)
if numOne > (numX * 2): # we have one or zero
if numZero > (numOne + (numX * 0.8)):
bitStream = bitStream + '0'
else:
bitStream = bitStream + '1'
else:
bitStream = bitStream + 'X'
devList.append(numZero)
devList.append(numOne)
#%% Load the sync signals only and compare the delay between the two
sync1, fs = sf.read(sync1_file)
sync2, fs = sf.read(sync2_file)
#%%
half_cycle = int(0.7 * 0.04 * fs)
plt.figure()
plt.plot(sync1[:half_cycle], label='device 1')
plt.plot(sync2[:half_cycle], label='device 2')
plt.legend()
#%%
samples = int((1 / 25) * fs * 0.7)
part_sync1 = sync1[:samples]
part_sync2 = sync2[:samples]
cc = signal.correlate(part_sync2, part_sync1, 'full')
peak = int(np.argmax(cc))
delay = peak - cc.size * 0.5
print(f'Device 2 is {delay} samples ahead of device 1')
#%%
plt.figure()
plt.plot(cc)
plt.plot(peak, cc[peak], '*')
plt.vlines(part_sync2.size, 0, np.max(cc))
#%% Now make the composite file which doesn't need to be delay adjusted - just < 1 sample difference.
multichannel_audio = np.zeros((sync1.size, 16))
all_audio = []
for i, each in enumerate(filenames):
def align_motion(self,
period=(-np.inf, np.inf),
side='left',
sd_thresh=10,
display=False):
# Get data samples within period
wheel = self.data['wheel']
self.alignment.label = side
self.alignment.to_mask = lambda ts: np.logical_and(
ts >= period[0], ts <= period[1])
camera_times = self.data['camera_times'][side]
cam_mask = self.alignment.to_mask(camera_times)
frame_numbers, = np.where(cam_mask)
if frame_numbers.size == 0:
raise ValueError('No frames during given period')
# Motion Energy
camera_path = self.video_paths[side]
roi = (*[slice(*r) for r in self.roi[side]], 0)
try:
# TODO Add function arg to make grayscale
self.alignment.frames = \
vidio.get_video_frames_preload(camera_path, frame_numbers, mask=roi)
except AssertionError:
self.log.error('Failed to open video')
return None, None, None
self.alignment.df, stDev = video.motion_energy(self.alignment.frames,
2)
self.alignment.period = period # For plotting
# Calculate rotary encoder velocity trace
x = camera_times[cam_mask]
Fs = 1000
pos, t = wh.interpolate_position(wheel.timestamps,
wheel.position,
freq=Fs)
v, _ = wh.velocity_smoothed(pos, Fs)
interp_mask = self.alignment.to_mask(t)
# Convert to normalized speed
xs = np.unique([find_nearest(t[interp_mask], ts) for ts in x])
vs = np.abs(v[interp_mask][xs])
vs = (vs - np.min(vs)) / (np.max(vs) - np.min(vs))
# FIXME This can be used as a goodness of fit measure
USE_CV2 = False
if USE_CV2:
# convert from numpy format to openCV format
dfCV = np.float32(self.alignment.df.reshape((-1, 1)))
reCV = np.float32(vs.reshape((-1, 1)))
# perform cross correlation
resultCv = cv2.matchTemplate(dfCV, reCV, cv2.TM_CCORR_NORMED)
# convert result back to numpy array
xcorr = np.asarray(resultCv)
else:
xcorr = signal.correlate(self.alignment.df, vs)
# Cross correlate wheel speed trace with the motion energy
CORRECTION = 2
self.alignment.c = max(xcorr)
self.alignment.xcorr = np.argmax(xcorr)
self.alignment.dt_i = self.alignment.xcorr - xs.size + CORRECTION
self.log.info(
f'{side} camera, adjusted by {self.alignment.dt_i} frames')
if display:
# Plot the motion energy
fig, ax = plt.subplots(2, 1, sharex='all')
y = np.pad(self.alignment.df, 1, 'edge')
ax[0].plot(x, y, '-x', label='wheel motion energy')
thresh = stDev > sd_thresh
ax[0].vlines(x[np.array(
np.pad(thresh, 1, 'constant', constant_values=False))],
0,
1,
linewidth=0.5,
linestyle=':',
label=f'>{sd_thresh} s.d. diff')
ax[1].plot(t[interp_mask], np.abs(v[interp_mask]))
# Plot other stuff
dt = np.diff(camera_times[[0, np.abs(self.alignment.dt_i)]])
fps = 1 / np.diff(camera_times).mean()
ax[0].plot(t[interp_mask][xs] - dt,
vs,
'r-x',
label='velocity (shifted)')
ax[0].set_title('normalized motion energy, %s camera, %.0f fps' %
(side, fps))
ax[0].set_ylabel('rate of change (a.u.)')
ax[0].legend()
ax[1].set_ylabel('wheel speed (rad / s)')
ax[1].set_xlabel('Time (s)')
title = f'{self.ref}, from {period[0]:.1f}s - {period[1]:.1f}s'
fig.suptitle(title, fontsize=16)
fig.set_size_inches(19.2, 9.89)
return self.alignment.dt_i, self.alignment.c, self.alignment.df
rhs = read_export_tool_csv(right_watch) lhs['n'] = (lhs['x'] ** 2 + lhs['y'] ** 2 + lhs['z'] ** 2) ** 0.5 rhs['n'] = (rhs['x'] ** 2 + rhs['y'] ** 2 + rhs['z'] ** 2) ** 0.5 # Synchronize signal******************** # Find shake area using protocol and by plotting the signal #example: plt.plot(lft.loc[range(100,8000),'norm']) lhs_shake_range = range(3000, 4000) rhs_shake_range = range(2000, 3000) # find offset # time_offset = ta.find_offset(lhs.loc[lhs_shake_range,'n'].as_matrix(), rhs.loc[rhs_shake_range,'n'].as_matrix()) a = lhs.loc[lhs_shake_range, 'n'].as_matrix() b = rhs.loc[rhs_shake_range, 'n'].as_matrix() offset = np.argmax(signal.correlate(a, b)) shift_by = a.shape[0] - offset time_offset = rhs.loc[rhs_shake_range[0] + shift_by, 'ts'] - lhs.loc[lhs_shake_range[0], 'ts'] # The link below says you need to subtract 1 from shift_by, but based on my plotting it looks like you don't need to # link: http://stackoverflow.com/questions/4688715/find-time-shift-between-two-similar-waveforms # Plot shift st = 500 en = 550 plt.plot(a[range(st, en)]) # plt.plot(b[range(st, en)]) plt.plot(b[range(st + shift_by, en + shift_by)]) # Segment data into samples *****************************************
# In[6]: from scipy.signal import convolve # In[7]: convolve(x, w, mode='valid') # In[8]: from scipy.signal import correlate # In[9]: correlate(x, w, mode='valid') # In[10]: correlate(x, w, mode='full') # In[11]: correlate(x, w, mode='same') # In[12]: x = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) w = np.array([[2, 0], [0, 0]]) # In[13]:
Problem Title: Solve the Approximate Pattern Matching Problem
URL: https://stepik.org/lesson/9/step/4?course=Stepic-Interactive-Text-for-Week-2&unit=8224
Code Challenge: Approximate Pattern Matching Problem: Find all approximate occurrences of a pattern in a string.
Input: Strings Pattern and Text along with an integer d.
Output: All starting positions where Pattern appears as a substring of Text with at most d mismatches.
'''
import sys
import utils
import numpy as np
from scipy import signal
def ApproximatePatternMatching(seq, pattern, d):
'Returns positions in seq where pattern appears with a hamming distance <= d'
ref_length = len(pattern)
text_seq = utils._convert_to_matrices(seq)
pattern_seq = utils._convert_to_matrices(pattern)
matches = signal.correlate(text_seq, pattern_seq, mode = 'valid').flatten()
return [i for i,x in enumerate(matches) if x >= ref_length-d]
if __name__ == '__main__':
pattern = sys.stdin.readline()[:-1]
seq = sys.stdin.readline()[:-1]
d = int(sys.stdin.readline()[:-1])
res = ApproximatePatternMatching(seq, pattern, d)
print(' '.join(map(str, res)))
def olf_bulb_10(Nmitral, H_in, W_in, P_odor_in, dam):
# Nmitral = 10 #number of mitral cells
Ngranule = np.copy(Nmitral) #number of granule cells pg. 383 of Li/Hop
Ndim = Nmitral + Ngranule #total number of cells
t_inh = 25
# time when inhalation starts
t_exh = 205
#time when exhalation starts
finalt = 395
# end time of the cycle
#y = zeros(ndim,1);
Sx = 1.43 #Sx,Sx2,Sy,Sy2 are parameters for the activation functions
Sx2 = 0.143
Sy = 2.86 #These are given in Li/Hopfield pg 382, slightly diff in her thesis
Sy2 = 0.286
th = 1 #threshold for the activation function
tau_exh = 33.3333
#Exhale time constant, pg. 382 of Li/Hop
exh_rate = 1 / tau_exh
alpha = .15 #decay rate for the neurons
#Li/Hop have it as 1/7 or .142 on pg 383
P_odor0 = np.zeros(Nmitral) #odor pattern, no odor
H0 = H_in #weight matrix: to mitral from granule
W0 = W_in #weights: to granule from mitral
Ib = np.ones((Nmitral, 1)) * .243 #initial external input to mitral cells
Ic = np.ones(
(Ngranule, 1)) * .1 #initial input to granule cells, these values are
#given on pg 382 of Li/Hop
signalflag = 1 # 0 for linear output, 1 for activation function
noise = np.zeros((Ndim, 1)) #noise in inputs
noiselevel = .00143
noisewidth = 7 #noise correlation time, given pg 383 Li/Hop as 9, but 7 in thesis
lastnoise = np.zeros((Ndim, 1)) #initial time of last noise pule
#******************************************************************************
#CALCULATE FIXED POINTS
#Calculating equilibrium value with no input
rest0 = np.zeros((Ndim, 1))
restequi = fsolve(lambda x: equi(x,Ndim,Nmitral,Sx,Sx2,Sy,Sy2,th,alpha,\
t_inh,H0,W0,P_odor0,Ib,Ic,dam),rest0) #about 20 ms to run this
np.random.seed(seed=23)
#init0 = restequi+np.random.rand(Ndim)*.00143 #initial conditions plus some noise
#for no odor input
init0 = restequi + np.random.rand(
Ndim) * .00143 #initial conditions plus some noise
#for no odor input
np.random.seed()
#Now calculate equilibrium value with odor input
lastnoise = lastnoise + t_inh - noisewidth #initialize lastnoise value
#But what is it for? to have some
#kind of correlation in the noise
#find eigenvalues of A to see if input produces oscillating signal
xequi = fsolve(lambda x: equi(x,Ndim,Nmitral,Sx,Sx2,Sy,Sy2,th,alpha,\
t_inh,H0,W0,P_odor_in,Ib,Ic,dam),rest0)
#equilibrium values with some input, about 20 ms to run
#******************************************************************************
#CALCULATE A AND DETERMINE EXISTENCE OF OSCILLATIONS
diffgy = celldiff(xequi[Nmitral:], Sy, Sy2, th)
diffgx = celldiff(xequi[0:Nmitral], Sx, Sx2, th)
H1 = np.dot(H0, diffgy)
W1 = np.dot(W0, diffgx) #intermediate step in constructing A
A = np.dot(H1, W1) #Construct A
dA, vA = lin.eig(A) #about 20 ms to run this
#Find eigenvalues of A
diff = (1j) * (dA)**.5 - alpha #criteria for a growing oscillation
negsum = -(1j) * (dA)**.5 - alpha #Same
diff_re = np.real(diff)
#Take the real part
negsum_re = np.real(negsum)
#do an argmax to return the eigenvalue that will cause the fastest growing oscillations
#Then do a spectrograph to track the growth of the associated freq through time
indices = np.where(
diff_re > 0) #Find the indices where the criteria is met
indices2 = np.where(negsum_re > 0)
#eigenvalues that could lead to growing oscillations
# candidates = np.append(np.real((dA[indices])**.5),np.real((dA[indices2])**.5))
largest = np.argmax(diff_re)
check = np.size(indices)
check2 = np.size(indices2)
if check == 0 and check2 == 0:
# print("No Odor Recognized")
dominant_freq = 0
else:
dominant_freq = np.real((dA[largest])**.5) / (
2 * np.pi) #find frequency of the dominant mode
#Divide by 2pi to get to cycles/ms
# print("Odor detected. Eigenvalues:",dA[indices],dA[indices2],\
# "\nEigenvectors:",vA[indices],vA[indices2],\
# "\nDominant Frequency:",dominant_freq)
#*************************************************************************
#SOLVE DIFFERENTIAL EQUATIONS TO GET INPUT AND OUTPUTS AS FN'S OF t
#differential equation to solve
teval = np.r_[0:finalt]
#solve the differential equation
sol = solve_ivp(lambda t,y: diffeq(t,y,Nmitral,Ngranule,Ndim,lastnoise,\
noise,noisewidth,noiselevel, t_inh,t_exh,exh_rate,alpha,Sy,\
Sy2,Sx,Sx2,th,H0,W0,P_odor_in,Ic,Ib,dam),\
[0,395],init0,t_eval = teval,method = 'RK45')
t = sol.t
y = sol.y
y = np.transpose(y)
yout = np.copy(y)
#convert signal into output signal given by the activation fn
if signalflag == 1:
for i in np.arange(np.size(t)):
yout[i, :Nmitral] = cellout(y[i, :Nmitral], Sx, Sx2, th)
yout[i, Nmitral:] = cellout(y[i, Nmitral:], Sy, Sy2, th)
#solve diffeq for P_odor = 0
#first, reinitialize lastnoise & noise
noise = np.zeros((Ndim, 1))
lastnoise = np.zeros((Ndim, 1))
lastnoise = lastnoise + t_inh - noisewidth
sol0 = sol = solve_ivp(lambda t,y: diffeq(t,y,Nmitral,Ngranule,Ndim,lastnoise,\
noise,noisewidth,noiselevel, t_inh,t_exh,exh_rate,alpha,Sy,\
Sy2,Sx,Sx2,th,H0,W0,P_odor0,Ic,Ib,dam),\
[0,395],init0,t_eval = teval,method = 'RK45')
y0 = sol0.y
y0 = np.transpose(y0)
y0out = np.copy(y0)
#convert signal into output signal given by the activation fn
if signalflag == 1:
for i in np.arange(np.size(t)):
y0out[i, :Nmitral] = cellout(y0[i, :Nmitral], Sx, Sx2, th)
y0out[i, Nmitral:] = cellout(y0[i, Nmitral:], Sy, Sy2, th)
#*****************************************************************************
#SIGNAL PROCESSING
#Filtering the signal - O_mean: Lowpass fitered signal, under 20 Hz
#S_h: Highpass filtered signal, over 20 Hz
fs = 1 / (.001 * (t[1] - t[0])) #sampling freq, converting from ms to sec
f_c = 15 / fs # Cutoff freq at 20 Hz, written as a ratio of fc to sample freq
flter = np.sinc(2 * f_c *
(t -
(finalt - 1) / 2)) * np.blackman(finalt) #creating the
#windowed sinc filter
#centered at the middle
#of the time data
flter = flter / np.sum(flter) #normalize
hpflter = -np.copy(flter)
hpflter[int(
(finalt - 1) / 2)] += 1 #convert the LP filter into a HP filter
Sh = np.zeros(np.shape(yout))
Sl = np.copy(Sh)
Sl0 = np.copy(Sh)
Sbp = np.copy(Sh)
for i in np.arange(Ndim):
Sh[:, i] = np.convolve(yout[:, i], hpflter, mode='same')
Sl[:, i] = np.convolve(yout[:, i], flter, mode='same')
Sl0[:, i] = np.convolve(y0out[:, i], flter, mode='same')
#find the oscillation period Tosc (Tosc must be greater than 5 ms to exclude noise)
Tosc0 = np.zeros(np.size(np.arange(5, 50)))
for i in np.arange(5, 50):
Sh_shifted = np.roll(Sh, i, axis=0)
Tosc0[i - 5] = np.sum(
np.diagonal(
np.dot(np.transpose(Sh[:, :Nmitral]),
Sh_shifted[:, :Nmitral])))
#That is, do the correlation matrix (time correlation), take the diagonal to
#get the autocorrelations, and find the max
Tosc = np.argmax(Tosc0)
Tosc = Tosc + 5
f_c2 = 1000 * (
1.3 /
Tosc) / fs #Filter out components with frequencies higher than this
#to get rid of noise effects in cross-correlation
#times 1000 to get units right
flter2 = np.sinc(2 * f_c2 * (t - (finalt - 1) / 2)) * np.blackman(finalt)
flter2 = flter2 / np.sum(flter2)
for i in np.arange(Ndim):
Sbp[:, i] = np.convolve(Sh[:, i], flter2, mode='same')
#CALCULATE THE DISTANCE MEASURES
#calculate phase via cross-correlation with each cell
phase = np.zeros(Nmitral)
for i in np.arange(1, Nmitral):
crosscor = signal.correlate(Sbp[:, 0], Sbp[:, i])
tdiff = np.argmax(crosscor) - (finalt - 1)
phase[i] = tdiff / Tosc * 2 * np.pi
#Problem with the method below is that it will only give values from 0 to pi
#for i in np.arange(1,Nmitral):
# phase[i]=np.arccos(np.dot(Sbp[:,0],Sbp[:,i])/(lin.norm(Sbp[:,0])*lin.norm(Sbp[:,i])))
OsciAmp = np.zeros(Nmitral)
Oosci = np.copy(OsciAmp) * 0j
Omean = np.zeros(Nmitral)
for i in np.arange(Nmitral):
OsciAmp[i] = np.sqrt(
np.sum(Sh[125:250, i]**2) / np.size(Sh[125:250, i]))
Oosci[i] = OsciAmp[i] * np.exp(1j * phase[i])
Omean[i] = np.average(Sl[:, i] - Sl0[:, i])
Omean = np.maximum(Omean, 0)
Ooscibar = np.sqrt(np.dot(
Oosci,
np.conjugate(Oosci))) / Nmitral #can't just square b/c it's complex
Omeanbar = np.sqrt(np.dot(Omean, Omean)) / Nmitral
maxlam = np.max(np.abs(np.imag(np.sqrt(dA))))
return yout, y0out, Sh, t, OsciAmp, Omean, Oosci, Omeanbar, Ooscibar, dominant_freq, maxlam
def matched_linear_filter(self):
linear_filter_vals = []
for i in self.filter_signal():
corr = signal.correlate(i, np.ones(128), mode='same') / 128
linear_filter_vals.append(corr)
return linear_filter_vals
def calc_cross_corr(value0, value1, Fs=7200, show=False, save_addr='../static/img/a.png', scot=False, time_scale=False,
test_ccor=False, plt_title="", frame_by_frame=False, max_shift=500):
""" Function to plot ccor in time and calc peak point of it """
# if test_ccor:
# value0 = np.roll(value0, 100) # just to test the scot
# *************************************************************************
value0 = value0 / np.max(np.abs(value0))
value0 = value0 - np.mean(value0)
value1 = value1 / np.max(np.abs(value1))
value1 = value1 - np.mean(value1)
if scot:
sqrt_abs_Sxx = np.sqrt(np.abs(np.fft.fft(scisig.correlate(value0, value0))))
sqrt_abs_Syy = np.sqrt(np.abs(np.fft.fft(scisig.correlate(value1, value1))))
xsi = 1 / sqrt_abs_Syy / sqrt_abs_Sxx
Sxy = np.fft.fft(scisig.correlate(value0, value1))
value0 = np.fft.ifft(Sxy * xsi)
value0 = value0 / np.max(np.abs(value0))
else:
value0 = scisig.correlate(value0, value1)
value0 = value0 / np.max(np.abs(value0))
# --- interpolate the sharp edges
mid = (len(value0) - 1) // 2
# value0[mid - 10: mid + 11] = 0
# for i in range(1, mid):
# if abs(value0[i] - value0[i - 1]) > 0.1:
# value0[i] = value0[i - 1]
# for i in reversed(range(mid, len(value0))):
# if abs(value0[i] - value0[i - 1]) > 0.1:
# value0[i - 1] = value0[i]
# ---- plot cross-correlation
plt.figure(4, figsize=(16, 8))
plt.clf()
if time_scale:
a = len(value0) / 2 / Fs
plt.xlabel("time [sec]")
else:
a = len(value0) / 2 # to have sample output
plt.xlabel("time [sample]")
plt.plot(np.linspace(-a, a, len(value0)), np.abs(value0))
plt.ylabel("normalized power")
plt.title(plt_title + "_zoomed")
plt.grid(True)
# ---- CHANGE THESE ACCORDING TO DATA ----
max_shift = int(max_shift * Fs)
lims = [-max_shift, max_shift, 0, 1]
plt.xlim([lims[0], lims[1]])
plt.ylim([lims[2], lims[3]])
# plt.show()
plt.xticks(np.linspace(lims[0], lims[1], 21))
plt.yticks(np.linspace(lims[2], lims[3], 11))
# plt.show()
# ---- CHANGE THESE ACCORDING TO DATA ----
# lims = [0, 300, 0, 1]
# plt.xlim([lims[0], lims[1]])
# plt.ylim([lims[2], lims[3]])
# plt.xticks(np.linspace(lims[0], lims[1], 21))
# plt.yticks(np.linspace(lims[2], lims[3], 11))
if show:
plt.show()
else:
if not os.path.exists(os.path.dirname(save_addr)):
os.mkdir(os.path.dirname(save_addr))
plt.savefig(save_addr)
# --- print cross corr peak point
mid = (len(value0) - 1) // 2
shift = np.argmax(np.abs(value0[mid - max_shift: mid + max_shift])) - max_shift # only search for max in 1 Sec distance
# value = np.abs(value0[shift])
# if time_scale:
# shift = shift / Fs
speed_of_sound = 3000
# print(shift)
# print(Fs)
# print(speed_of_sound)
print("shift amount = {:4f} Sec, {} Samples, {:3f} Meter".format(shift / Fs, shift, shift / Fs * speed_of_sound))
# print("shift amount = {} Meter".format(shift))
# else:
# print("shift amount = {} Samples, with confedence = {:3f}%".format(shift, value * 100))
# shift = shift / Fs *
# print("shift amount = {} Meter".format(shift))
return shift / Fs
def xcorr(x, y, normed=True):
correls = correlate(x, y)
if normed:
correls /= np.sqrt(np.dot(x, x) * np.dot(y, y))
return correls
"""
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image
from scipy.signal import convolve, correlate
# jpg 파일 오픈
img = Image.open('sample.jpg')
img_pixel = np.array(img)
print(img_pixel.shape) # (height, width, color-depth)
# 머신 러닝 라이브러리에 따라서 color 표기의 위치가 달라짐.
# Tensorflow: channel-last 방식. color-depth가 3차원 배열의 마지막 차원
# Theano: channel-first 방식. color-depth가 3차원 배열의 첫번째 차원 (c,h,w)
# Keras: 두가지 방식 모두 지원.
plt.imshow(img_pixel)
plt.show()
# 이미지의 RED 값 정보
print(img_pixel[:, :, 0])
# (3, 3, 3) 필터
filter = np.zeros((8, 8, 3))
filter[0, 0, :] = 255
# transformed = convolve(img_pixel, filter, mode='same')
transformed = correlate(img_pixel, filter, mode='same')
plt.imshow(transformed.astype(np.uint8))
plt.show()
def checkData(self, y1, y2):
""" Called by ,fileLoad()
:param y1: ch1 data array (Force)
:param y2: ch2 data array (Accel)
:return: None
"""
# /\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
# PUT A PULSE ON Ch1 TO TEST GLITCH DETECTION
#
# noise_1 = np.random.rand(np.max(y1.shape)) / 500
# noise_2 = np.random.rand(np.max(y1.shape)) / 500
# y1 = noise_1
# y2 = noise_2
# y1[480] = 0.5
#
# /\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
# ========================== SATURATION CHECK BEGIN ==========================\
#
y1_Min = np.min(y1) # Getting min / max
y1_Max = np.max(y1)
y2_Min = np.min(y2)
y2_Max = np.max(y2)
max_abs1 = max(abs(y1_Min), abs(y1_Max)) # ch1 absolute peak
max_abs2 = max(abs(y2_Min), abs(y2_Max)) # ch2 absolute peak
max_abs = max(max_abs1, max_abs2) # Greater absolute maximum peak
#
if max_abs < c.satur_threshold: # Saturation check
is_Saturated = False
else:
is_Saturated = True
doBeep(on_list = alarm_3_S[0],
off_list = alarm_3_S[1])
print(Saturation_msg, "max_abs =", max_abs)
# #
# ========================== SATURATION CHECK END ============================/
# ========================== GLITCH TESTING BEGIN ============================\
#
global plot_debug # Access to the global plot_debug
W = 1 # Lateral range width for each side around the peak sample
is_err1 = False
is_err2 = False
#----------- NEW TEST BASED ON THE DIFFERENTIATION OF THE GLITCH (DIRAC DELTA FUNCTION)
y1_d = np.diff(y1)
y2_d = np.diff(y2)
indx1 = min(min(np.nonzero(np.abs(y1) == max_abs1))) # Index of max(abs(y1))
indx2 = min(min(np.nonzero(np.abs(y2) == max_abs2))) # Index of max(abs(y2))
if indx1 < (np.max(y1.shape) -2) and (np.max(abs(y1_d[indx1-1] - max_abs1)) < max_abs1 / 50):
is_err1 = True
# #
if indx2 < (np.max(y2.shape) -2) and (np.max(abs(y2_d[indx1-1] - max_abs1)) < max_abs2 / 50):
is_err2 = True
# #
#-------------------------------------------------------------------------------
if is_err1: print(Glitch_msg, "on Ch1")
if is_err2: print(Glitch_msg, "on Ch2")
if is_err1 or is_err2:
doBeep(on_list = alarm_1_S[0], off_list = alarm_1_S[1])
# #
# if is_err1 or is_err2 or plot_debug:
# mean1 = int(round(1000*mean_range1))
# max1 = int(round(1000*max_abs1 / 2))
# mean2 = int(round(1000*mean_range2))
# max2 = int(round(1000*max_abs2 / 2))
# print("==============================")
# print(" Glitches are absent if:")
# print(" mean_range > max_absX/2")
# print("==============================")
# print(" ch1: {:03d}".format(mean1), " {:03d}".format(max1), " [mV]")
# print("------------------------------")
# print(" ch2: {:03d}".format(mean2), " {:03d}".format(max2), "[mV]")
# print("------------------------------")
# print(" ch1 indexes: ", range_indx1)
# print(" ch2 indexes: ", range_indx2)
# print("------------------------------")
# # #
# ============================ GLITCH TESTING END ============================/
# ======================= CHANNELS SWAP TESTING BEGIN ========================\
#
""" Sometime the first acquisition can swap ch1 with ch2, here we detect that occurrence, and in the case,
we recovery by a swap between ch1 and ch2.
1) The autocorrelations of y1 and y2 are calculated.
2) The max absolute peaks of the autocorrelations are calculated.
3) Each one of the autocorrelation amplitudes are normalized using the absolute peaks of point (2).
4) The normalized autocorrelations are rounded to 1 decimal to exclude little oscillations around 0.
5) The differentiation of the sign changements of the normalized and rounded correlations is calculated.
6) The differentiations of point (5) are cumulated to obtain the final scalar count.
7) The ch1 Force signal is a well behaved and then bandlimited pulse with only two zero crossing
(excluding noise), by contrast the ch2 Accel signal being a derivative (accelerometer signal)
has surely more sign changements, consequently when the total sign changes of ch1 exceeds that of ch2
the channels are swapped.
"""
upper = int(3 * self.indx_echo_0) # Upper index limit for checking
corr_y1 = correlate(y1[0:upper], y1[0:upper], mode='same')
corr_y2 = correlate(y2[0:upper], y2[0:upper], mode='same')
pk_abs_corr_1 = np.max(np.abs(corr_y1))
pk_abs_corr_2 = np.max(np.abs(corr_y2))
corr_y1 = np.round(corr_y1 / pk_abs_corr_1, 1)
corr_y2 = np.round(corr_y2 / pk_abs_corr_2, 1)
nz_diff_corr_y1 = (np.diff(np.sign(corr_y1), n=1) != 0).sum()
nz_diff_corr_y2 = (np.diff(np.sign(corr_y2), n=1) != 0).sum()
#
if nz_diff_corr_y1 < nz_diff_corr_y2:
is_swapped = False
else:
is_swapped = True
# #
if plot_debug:
print("Actual loaded file n°", self.fileIndex)
print("\n" + "Zero crossing comparison:", nz_diff_corr_y1, " < ", nz_diff_corr_y2, " ", not is_swapped)
# #
print(" Good if:")
print(" nz_diff_corr_y1 < nz_diff_corr_y2")
print("-----------------------------------")
print(" ", nz_diff_corr_y1, " | ", nz_diff_corr_y2)
print("-----------------------------------")
if is_swapped:
print("\n" + "/" * 35)
print(" ERROR: Swapped ch1, ch2")
print(" CORRECTION DONE!")
print("/" * 35 + "\n")
y1, y2 = y2, y1 # Swap Channels
self.y1_full = self.y1
self.y2_full = self.y2
# #
# ======================== CHANNELS SWAP TESTING END =========================/
self.plotData()
import numpy as np import scipy.linalg as la import scipy.signal as signal N = 100 # num of samples sRate = 25 # sampling rate z = np.linspace(0, 2 * np.pi, num=N) x = np.sin(2 * np.pi * z) + np.sin(1 * np.pi * z) autocorrMtx = la.toeplitz(signal.correlate(x, x, mode='full')) print(len(autocorrMtx[0]))
emphasize_1 = 1
K = 2 * np.pi / Fsr
template_0 = [0 for i in range(chunk_size)]
template_1 = [0 for i in range(chunk_size)]
for s in range(samp_per_bit):
template_0.append(emphasize_0 * -np.cos(s * K * fzero))
template_1.append(emphasize_1 * -np.cos(s * K * fone))
# correlate each chunk
correlate_0 = []
correlate_1 = []
c = 0
while c < len(data):
chunk = data[c:c + chunk_size - 1]
c0 = correlate(chunk, template_0, 'full').tolist()
c1 = correlate(chunk, template_1, 'full').tolist()
for i in range(chunk_size):
c0[i] *= -c0[i]
c1[i] *= c1[i]
#plt.subplot(2,1,1)
#plt.plot(chunk)
#plt.subplot(2,1,2)
#plt.plot(range(len(c0)), c0, 'r-', c1, 'b-')
#plt.show()
correlate_0 += c0[0:chunk_size]
correlate_1 += c1[0:chunk_size]
c += chunk_size
# low pass filter
def correlation(current, data, data_len, transformer):
des = data[0][0]["desired"][:data_len]
out = current[0][transformer][0][
"output"][:data_len] if current is not None else des
return s.correlate(out, des)
def Recognition(input_img, input_filter, max_conv, min_conv):
### Forward Pass
# Global variable initialization
global convolved_nodes
global temp
global max_conv_t
global min_conv_t
# Convolution
for i in range(0, input_filter.shape[0]):
convolved_nodes[i] = signal.correlate(input_img,
input_filter[i],
mode="valid")
# print("MAX MIN")
# print(np.amax(convolved_nodes))
# print(np.amin(convolved_nodes))
# max_conv_t = np.amax(convolved_nodes)
# if max_conv_t > max_conv:
# max_conv = max_conv_t
# else:
# max_conv = max_conv
# min_conv_t = np.amin(convolved_nodes)
# if min_conv_t < min_conv:
# min_conv = min_conv_t
# else:
# min_conv = min_conv
# print("CONV NODES:")
# print(convolved_nodes)
# Sigmoid activation of convolution node
convolved_nodes_sigmoid = relu_activation(convolved_nodes)
# print("CONV RELU:")
# print(convolved_nodes_sigmoid)
# print(convolved_nodes_sigmoid.shape)
# Flattening of sigmoid activated convolution layer
convolved_nodes_sigmoid_flat = convolved_nodes_sigmoid.reshape(
1, total_weights)
# print("CONV FLAT:")
# print(convolved_nodes_sigmoid_flat)
# Fully connected layer
output_nodes_flat = np.matmul(convolved_nodes_sigmoid_flat,
convolved_nodes_to_output_nodes)
# print("MAX MIN FC")
# print(np.amax(output_nodes_flat))
# print(np.amin(output_nodes_flat))
# max_conv_t = np.amax(output_nodes_flat)
# if max_conv_t > max_conv:
# max_conv = max_conv_t
# else:
# max_conv = max_conv
# min_conv_t = np.amin(output_nodes_flat)
# if min_conv_t < min_conv:
# min_conv = min_conv_t
# else:
# min_conv = min_conv
print("OUTPUT NODES:")
print(output_nodes_flat)
# Softmax activation of output node
output_nodes_flat_column = np.transpose(
output_nodes_flat) #.reshape(10,1)#for column comparison
softmax_output, softmax_1_minus_max = softmax(output_nodes_flat_column)
# print("MAX MIN")
# print(np.amax(softmax_output))
# print(np.amin(softmax_output))
max_conv_t = np.amax(softmax_output)
if max_conv_t > max_conv:
max_conv = max_conv_t
else:
max_conv = max_conv
min_conv_t = np.amin(softmax_output)
if min_conv_t < min_conv:
min_conv = min_conv_t
else:
min_conv = min_conv
return output_nodes_flat_column, softmax_output, min_conv, max_conv
