def filteringData(self, data):
syg = ag.pasmowozaporowy(data, self.fs, self.notchCutOff1,
self.notchCutOff2)
syg = ag.pasmowoprzepustowy(syg, self.fs, self.bandpassCutOff1,
self.bandpassCutOff2)
return self.normalizeData(syg[5 * self.fs:(5 + self.seconds) *
self.fs])
def filteringData(self, filePath):
data = np.genfromtxt(filePath, delimiter=",")
data = data.T
syg = ag.pasmowozaporowy(data[self.electrodeNumber],
self.numberOfGenes, self.notchCutOff1,
self.notchCutOff2)
syg = ag.pasmowoprzepustowy(syg, self.numberOfGenes,
self.bandpassCutOff1, self.bandpassCutOff2)
return self.normalizeData(syg[5 * self.numberOfGenes:6 *
self.numberOfGenes])
dane = pd.read_csv('sub-01_trial-01.csv',
names=['numer', 'ch1', 'ch2', 'ch3', 'ch4', 'bodziec'])
czas = int(len(dane['ch1']) / czestProbkowania)
t = np.linspace(0, czas, czas * czestProbkowania)
#wykres przed filtracją
plt.plot(t, dane['ch1'][0:czas * czestProbkowania])
plt.xlabel("Czas [s]")
plt.ylabel("Amplituda [mV]")
plt.show()
#filtracja
przefiltrowany1 = ag.pasmowozaporowy(dane['ch1'], czestProbkowania, 49, 51)
przefiltrowany2 = ag.pasmowoprzepustowy(przefiltrowany1, czestProbkowania, 1,
50)
#wykres po filtracji
plt.plot(t, przefiltrowany2[0:czas * czestProbkowania])
plt.xlabel("Czas [s]")
plt.ylabel("Amplituda [mV]")
plt.show()
#pętla przedstawiająca wymrugane cyfry
kod = []
cnt = 0
prev = 0
for i in przefiltrowany2:
if i >= 0.1 and prev < 0.1:
kod.append(dane['bodziec'][cnt])
prev = i
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import aseegg as ag
dane = pd.read_csv(r"sub-01_trial-05.csv", delimiter=',', engine='python')
czestosc_probkowania = 200
t = np.linspace(0, 37.96, 200 * 37.96)
sygnal = dane["k2"]
filtr = ag.pasmowozaporowy(sygnal, czestosc_probkowania, 49, 51)
filtr2 = ag.pasmowoprzepustowy(filtr, czestosc_probkowania, 1, 50)
plt.plot(sygnal) #Rycina 1. Wykresy sygnału przed filtracją.
plt.plot(filtr2) #Rycina 2. Wykresy sygnału po filtracji.
plt.xlabel("Czas [s]")
plt.ylabel("Amplituda [-]")
plt.show()
return child1, child2
def create_population(size1,size2):
return np.asarray([[int(round(random.random(),0)) for x in range(size1)] for y in range(size2)])
def tournament_selection(population,fitness):
new_population=[]
for i in range(len(fitness)):
players_list=random.sample(range(len(fitness)), players_in_tournament)
players_fitness=[fitness[players_list[j]] for j in range(len(players_list))]
new_population.append(population[:,players_list[players_fitness.index(max(players_fitness))]])
#print(players_list[players_fitness.index(max(players_fitness))], max(players_fitness))
return np.asarray(new_population).T
t=np.linspace(0,1,250)
signal14=ag.pasmowoprzepustowy(0.1*np.sin(2*np.pi*t*14)+[0.9*random.random() for x in range(250)],250,1,50)
signal8=ag.pasmowoprzepustowy(0.1*np.sin(2*np.pi*t*8)+[0.9*random.random() for x in range(250)],250,1,50)
def bin2dec(bin_list):
return sum([bin_list[i]*pow(2,len(bin_list)-i-1) for i in range(len(bin_list)-1,-1,-1)])
def decode_indv(indv):
signal=np.empty([250])
for i in range(0,len(indv),n_bits):
indv_float= pow(-1,i+1)*exp(pow(-1,i)*bin2dec(indv[i+2:i+n_bits]))
if i%(n_bits*2)==0:
signal=signal+indv_float*np.sin(2*np.pi*(int(i/(n_bits*2))+1)*t)
else:
signal=signal+indv_float*np.cos(2*np.pi*(int(i/(n_bits*2))+1)*t)
mmin=min(signal)
import numpy as np
import matplotlib.pyplot as plt
import aseegg as ag
import pandas as pd
import scipy.stats as st
dane = pd.read_csv(r"sub-01_trial-03.csv", delimiter=',', engine='python')
prob = 200
t = np.linspace(0, 37.96, 200 * 37.96)
sygnal = dane['kol2']
sygnalfiltr = ag.pasmowozaporowy(sygnal, prob, 49, 51)
sygnalfiltr2 = ag.pasmowoprzepustowy(sygnalfiltr, prob, 1, 50)
plt.plot(sygnalfiltr2)
plt.xlabel("Czas [s]")
plt.ylabel("Amplituda [-]")
plt.show()
koda = []
for i in range(len(sygnalfiltr2)):
if sygnalfiltr2[i] > 0.2:
koda.append(dane.kol6[i])
koda2 = []
for i in range(len(koda)):
if koda[i] != koda[i - 1]:
koda2.append(koda[i])
print("Wymrugany kod:", koda2)
names=['-', 'kanal1', 'kanal2', 'kanal3', 'kanal4', 'cyfra'])
fs = 200
data1 = data['kanal1']
data4 = data['cyfra']
t = int(len(data1) / fs)
#linspace(first number, last number, how many numbers in array)
x = np.linspace(0, t, t * fs)
#prefiltered
plt.plot(x, data1[0:t * fs], label='sygnał')
plt.ylabel('mikrowolty [mV]')
plt.xlabel('czas [s]')
plt.legend(loc='upper right')
#plt.show()
#filtered
filtr1 = ag.pasmowozaporowy(data1, fs, 49, 51)
filtr2 = ag.pasmowoprzepustowy(filtr1, fs, 1, 50)
plt.plot(x, filtr2[0:t * fs], label='sygnał')
plt.ylabel('mikrowolty [mV]')
plt.xlabel('czas [s]')
plt.legend(loc='upper right')
#plt.show()
plt.plot(x, data4[0:t * fs])
plt.ylabel('cyfra [-]')
plt.xlabel('czas [s]')
plt.legend(loc='upper right')
#plt.show()
#decoded(print())
#przefiltrowany sygnal, mrugnięcia to wzniesienie na y, wzniesienie czyli wartość y większą od Q, ale w przedziale od Q do Q, do każdej wartości dopasowana jest cyfra, dodać tę cyfrę do arraya
#Q = 0.12 wyczytane z
licznik = 0
dane = pd.read_csv(r"C:\Users\jpalu\Desktop\sub1trial10.csv",
delimiter=',',
engine='python')
sygnal = dane['kolumna2']
wyswietlane = dane['kolumna6']
t = np.linspace(0, 37.89, 200 * 37.89)
probkowanie = 200
czestOdciecia1 = 49
czestOdciecia2 = 51
przefiltrowany = ag.pasmowozaporowy(sygnal, probkowanie, czestOdciecia1,
czestOdciecia2)
przepust1 = 1
przepust2 = 50
przepuszczony = ag.pasmowoprzepustowy(sygnal, probkowanie, przepust1,
przepust2)
#filtracja sygnału- filtry: pasmowozaporowy i pasmowoprzepustowy
'''plt.subplot(3,1,1)
plt.plot(t,sygnal)
plt.title("Sygnał dla danych sub1trial10")
plt.xlabel('Czas [s]')
plt.ylabel('Amplituda [-]')
plt.subplot(3,1,2)
plt.plot(t,przefiltrowany)
plt.title("Sygnał po zastosowaniu filtra pasmowozaporowego")
plt.xlabel('Czas [s]')
plt.ylabel('Amplituda [-]')
plt.subplot(3,1,3)
plt.plot(t,przepuszczony)
plt.title("Sygnał po zastosowaniu filtra pasmowoprzepustowego")
import pandas as pd
import aseegg as ag
dane = pd.read_csv(r"sub-01_trial-07.csv", delimiter=',', engine='python')
sygnal = dane['2']
liczby = dane['6']
t = np.linspace(0, 113.165, 200 * 113.165)
plt.subplot(2, 1, 1)
plt.plot(t, sygnal)
plt.xlim([0, 35])
plt.xlabel("Czas [s]")
plt.ylabel("Amplituda [-]")
plt.title("Ryc. 1.1. Sygnał przed filtracją")
przefiltrowany = ag.pasmowozaporowy(sygnal, 200, 49, 51)
przefiltrowany2 = ag.pasmowoprzepustowy(przefiltrowany, 200, 1, 50)
plt.subplot(2, 1, 2)
plt.plot(t, przefiltrowany2)
plt.xlim([0, 35])
plt.xlabel("Czas [s]")
plt.ylabel("Amplituda [-]")
plt.title("Ryc. 1.2. Sygnał przefiltrowany")
plt.show()
plt.plot(t, liczby)
plt.xlim([0, 35])
plt.xlabel("Czas [s]")
plt.ylabel("Amplituda [-]")
plt.show()
tab = []
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import aseegg as ag
dane = pd.read_csv(r"sub-007_trial-07.csv", delimiter=',', engine='python')
baza = pd.DataFrame(dane)
sygnal = baza["b"]
liczba = baza["f"]
t = np.linspace(0, 37.84, 200 * 37.84)
sygnalprzef = ag.pasmowozaporowy(sygnal, 200, 49, 51)
sygnalprzefiltrowany = ag.pasmowoprzepustowy(sygnalprzef, 200, 1, 50)
plt.plot(t, sygnal)
plt.ylabel("Amplituda [-]")
plt.xlabel("Czas [s]")
plt.show()
plt.plot(t, sygnalprzef)
plt.ylabel("Amplituda [-]")
plt.xlabel("Czas [s]")
plt.show()
plt.plot(t, sygnalprzefiltrowany)
plt.ylabel("Amplituda [-]")
plt.xlabel("Czas [s]")
plt.show()
print(sygnal.mean())
print(sygnal.max())
print((1.5847468537697242 + 3.719023605585575) / 2)
mrug = []
mrug2 = []
j = 1
for i in range(len(sygnal)):
if sygnal[i] > 1.8:
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import aseegg as ag
t = np.linspace(0, 37.97, 200 * 37.97)
prob = 200
dane = pd.read_csv(r"sub1trial20.csv", delimiter=',', engine='python')
sygnal = dane["kol1"]
sygnal1 = dane["kol5"]
przefiltrowany = ag.pasmowozaporowy(sygnal, prob, 49, 51)
przefiltrowany = ag.pasmowoprzepustowy(przefiltrowany, prob, 1, 50)
plt.subplot(2, 2, 1)
plt.title("Sygnał")
plt.ylabel('Amplituda [µV]')
plt.xlabel('Czas [s]')
plt.plot(t, sygnal)
plt.subplot(2, 2, 3)
plt.title("Cyfry wyświetlane na ekranie")
plt.ylabel('Wyświetlana cyfra')
plt.xlabel('Czas [s]')
plt.plot(t, sygnal1)
plt.subplot(2, 2, 2)
plt.title("Przefiltrowany sygnał")
plt.ylabel('Amplituda [µV]')
plt.xlabel('Czas [s]')
plt.plot(t, przefiltrowany)
def filtering_data(self, data):
syg = ag.pasmowozaporowy(data, self.fs, self.notch_cut_off1,
self.notch_cut_off2)
syg = ag.pasmowoprzepustowy(syg, self.fs, self.bandpass_cut_off1,
self.bandpass_cut_off2)
return syg[:self.max_sec * self.fs]
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import csv
data = pd.read_csv('sub1trial8.csv', delimiter=',', engine='python')
data.columns = ['-','kanal1', 'kanal2', 'kanal3', 'kanal4','cyfra' ]
fs=200
dlugosc = data['-']
kanal1=data['kanal1']
#print(kanal1)
t = 7589/fs
t = int(t)
x =np.linspace(0,t,t*fs)
filtrowaniezaporowe = ag.pasmowozaporowy(kanal1, fs, 49, 51)
filtrowanieprzepustowe = ag.pasmowoprzepustowy(filtrowaniezaporowe, fs, 1, 50)
#oprócz starej pętli mógłbym spróbować zrobić coś z tej, która printuje czas, w którym osoba mrugnęła i dopasować go do cyfry, jednak nie mam czasu z związku z sesją
#licznik=0
#z = 0
#czasmrugania = []
#for i in filtrowanieprzepustowe:
# if i>=0.10 and z<0.10:
# czasmrugania.append([licznik/200])
# z=i
# licznik+=1
#print(czasmrugania)
licznik=0
z = 0
mrugane = []
for i in filtrowanieprzepustowe:
dane = pd.read_csv(
"C:/Users/Oliwia/Desktop/zadanie/proba113.csv",
delimiter=',',
engine="python",
names=['number', 'sub01', 'sub02', 'sub03', 'sub04', 'last'])
#1 kolumna
signal = dane['sub01']
probkowanie = 200
time = len(signal) / 200
t = np.linspace(0, time, time * 200)
#filter
filter1 = ag.pasmowozaporowy(signal, probkowanie, 49, 51)
filter2 = ag.pasmowoprzepustowy(filter1, probkowanie, 1, 50)
#before
#plt.plot(t, signal, color="red")
#plt.xlabel("Czas[s]",size=10)
#plt.ylabel("Amplituda[-]",size=10)
#plt.show()
#after
#plt.plot(t,filter2, color ="brown")
#plt.xlabel("Czas[s]",size=10)
#plt.ylabel("Amplituda[-]",size=10)
#plt.show()
#last column
#last = dane['last']
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import aseegg as ag
dane = pd.read_csv('sub-01_trial-03.csv', delimiter=',', engine='python')
mojeDane = dane[1]
czestotliwoscp = 200
przefiltrowane = ag.pasmowoprzepustowy(mojeDane, czestotliwoscp, 1,50)
przefiltrowane = ag.pasmowozaporowy(przefiltrowane, czestotliwoscp, 49, 51)
ag.spektrogram(mojeDane, 200)
ag.spektrogram(przefiltrowane, 200)
import aseegg as ag
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
dane = pd.read_csv("sub1trial4.csv", names=['numer','kanal1','kanal2','kanal3','kanal4','wartosc'])
kanal1 = dane['kanal1']
wartosc = dane['wartosc']
probkowanie=200
popasmowozaporowy= ag.pasmowozaporowy(kanal1, probkowanie, 49, 51)
popasmowoprzepustowy= ag.pasmowoprzepustowy(popasmowozaporowy, probkowanie, 1, 50)
wartoscpoprzednia=0
for i in range(len(popasmowoprzepustowy)):
if popasmowoprzepustowy[i]>=0.1:
if wartoscpoprzednia<0.1:
print(wartosc[i])
wartoscpoprzednia=popasmowoprzepustowy[i]
def read_data(filePath):
data = pd.read_csv(filePath, delimiter=",", engine="python", header=None)
syg = ag.pasmowozaporowy(data.T.loc[14], 256, 49, 51)
syg = ag.pasmowoprzepustowy(syg, 256, 1, 50)
return pd.Series(syg[5 * 256:6 * 256])
czestotliwosc1 = 10
czestotliwosc2 = 25
czestotliwosc3 = 40
czestProbkowania = 500
a1 = 5
a2 = 10
a3 = 20
czas = 1
czas2 = 3
t = np.linspace(0, czas, czas * czestProbkowania)
t2 = np.linspace(0, czas2, czas2 * czestProbkowania)
f = np.linspace(0, 256, 3*500)
sygnal=np.concatenate([np.concatenate([a1*np.sin(2*np.pi*czestotliwosc1*t), a2*np.sin(2*np.pi*czestotliwosc2*t)]), a3*np.sin(2*np.pi*czestotliwosc3*t)])
transformata = ag.FFT(sygnal)
przefiltrowany = ag.pasmowoprzepustowy(sygnal, czestProbkowania, 15,30)
transformata2 = ag.FFT(przefiltrowany)
plt.plot(t2, sygnal)
plt.xlabel("Czas [s]")
plt.ylabel("Amplituda [-]")
plt.show()
plt.plot(t2, przefiltrowany)
plt.xlabel("Czas [s]")
plt.ylabel("Amplituda [-]")
plt.show()
plt.stem(f, transformata)
plt.xlabel("Częstotliwość [Hz]")
plt.ylabel("Amplituda [-]")
plt.show()
plt.stem(f, transformata2)
def filtering_data(self,data):
syg=ag.pasmowozaporowy(data, self.fs, self.notch_cut_off1,self.notch_cut_off2)
syg=ag.pasmowoprzepustowy(syg, self.fs, self.bandpass_cut_off1,self.bandpass_cut_off2)
return self.normalize_data(syg[self.fs*5+36:(5+self.seconds)*self.fs+36])
import numpy as np
import matplotlib.pyplot as plt
import aseegg as ag
import pandas as pd
dane = pd.read_csv(r"C:\Users\NataliaA\Desktop\hci\sub-01_trial-04_3.csv",
delimiter=',',
engine='python')
czestProbk = 200
t = np.linspace(0, 37.96, 200 * 37.96)
sygnal = dane['Kol1']
zfiltrem = ag.pasmowozaporowy(sygnal, czestProbk, 49, 51)
zfiltrem2 = ag.pasmowoprzepustowy(sygnal, czestProbk, 1, 50)
plt.plot(t, sygnal)
plt.xlabel("Czas [s]")
plt.ylabel("Amplituda [-]")
plt.show()
plt.plot(t, zfiltrem)
plt.xlabel("Czas [s]")
plt.ylabel("Amplituda [-]")
plt.show()
plt.plot(t, zfiltrem2)
plt.xlabel("Czas [s]")
plt.ylabel("Amplituda [-]")
plt.show()
print(dane)
