def online_processing_5_1():
import numpy as np
eeg = resonance.input(0)
eeg_windows = resonance.pipe.windowizer(eeg, 10, 10)
as_events = resonance.pipe.transform_to_event(eeg_windows, makeEvent)
#conditional = resonance.pipe.filter_event(as_events, lambda evt: float(evt) > 0)
evt = ConditionalEventNotTooOften(0, 2)
conditional = resonance.pipe.filter_event(as_events, evt)
window_size = 50
window_shift = -50
baseline_begin_offset = 0
baseline_end_offset = 50
eeg_windowized = resonance.cross.windowize_by_events(eeg, conditional, window_size, window_shift)
baselined = resonance.pipe.baseline(eeg_windowized, slice(baseline_begin_offset, baseline_end_offset))
result_ = resonance.pipe.transform_to_event(baselined, makeEvent2)
'''
думал по условию брать baselined массив и пихать его в список примеров, которые потом будут подаваться классификатору
Но в этой ф-ции так просто это не сделать
Правильно ли я понял, что нужен какой-то класс, который будет прокручиваться из недр прцессинга и указываться как параметр?
'''
#как делать логи тоже не понял пока
res_events = np.array(result_)
np.savetxt('d:/Projects/BCI_EyeLines_Online_2020/rpe/test1.txt', res_events)
resonance.createOutput(result_, 'Evtout2')
def code():
inputs = [resonance.input(idx) for idx in range(0, len(si))]
args = inputs + list(arguments)
outputs = processor(*args)
if isinstance(outputs, list):
for idx, out in enumerate(outputs):
resonance.createOutput(out, 'out_{}'.format(idx))
else:
resonance.createOutput(outputs, 'out_0')
def online_processing():
alldata = resonance.input(0)
eeg_Filtered_Referenced, emg_Notch_HPFiltered = FiltrationAndRefCorrection(alldata)# селективная фильтрация каналов + корректировка ЭЭГ на референт
resonance.createOutput(eeg_Filtered_Referenced, 'EEG_Filtered_Referenced')
resonance.createOutput(emg_Notch_HPFiltered, 'EMG_Notch_HPFiltered')
#просматриваем эвенты и меняем рабочий статус системы согласно входящим командам
events = resonance.input(1)
cmd_input = resonance.pipe.filter_event(events, UpdateWorkState)
resonance.createOutput(cmd_input, 'EvtWorkState')#входящие команды эхом отправляем в эвентный поток для контроля
window_size = 200
window_shift = -200
baseline_begin_offset = 0
baseline_end_offset = 100
thresholdForEEGInVolts = 20#0.0005 # пороговая амплитуда помехи для оценки кандидата на нецелевую эпоху
thresholdForEMGInVolts = 0.1#0.05 # пороговая амплитуда ЭМГ для оценки кандидата на целевую эпоху
intervalEvtToEvtInSec = 3 # интервал между кандидатами на целевую/нецелевую эпоху, сек
#Формируем эпохи для нецелевого класса
#просмотр шинкованной ЭЭГ на предмет кандидатов на формирование нецелевых эпох
eeg_windows = resonance.pipe.windowizer(eeg_Filtered_Referenced, 50, 50)#шинкуем ЭЭГ на мелкие окна
eeg_as_events = resonance.pipe.transform_to_event(eeg_windows, makeEvent)
eeg_windowized = resonance.cross.windowize_by_events(eeg_Filtered_Referenced, eeg_as_events, window_size, window_shift)
EvtsMaxAmplitudes = resonance.pipe.transform_to_event(eeg_windowized, makeEvent) # считаем максимумы амплитуд во взятых окнах
evt = GetEventsForUntargetedEpochs(thresholdForEEGInVolts, intervalEvtToEvtInSec)#экземпляр получит значение, только в режиме NeedEpoching
cndtnlEvtForUntargetEpochs = resonance.pipe.filter_event(EvtsMaxAmplitudes, evt)#оставляем эвенты только тех окон, которые проходят по порогу амплитуд и интервалов
#resonance.createOutput(cndtnlEvtForUntargetEpochs, 'EvtCndtnlForUntargetEpochs')
#берём окна для нецелевых эпох по отфильтрованным событиям (просмотр максимумов амплитуд (отбрасывание артефактных окон) по всему окну, интервалов между окнами)
eeg_windowized_ = resonance.cross.windowize_by_events(eeg_Filtered_Referenced, cndtnlEvtForUntargetEpochs, window_size, window_shift)
baselinedEpoch = resonance.pipe.baseline(eeg_windowized_, slice(baseline_begin_offset, baseline_end_offset))
#поскольку визуализации объекта окон пока нет, то преобразуем к эвенту чтобы посмотреть выхлоп во вьювере
exhaustEvt = resonance.pipe.transform_to_event(baselinedEpoch, makeEvtAndAddUntargetEpochToList)
resonance.createOutput(exhaustEvt, 'UntargetEpochEvt')
#та же история взятия эпох для подачи обученному классификатору, только тогда intervalEvtToEvtInSec=0
# Формируем целевые эпохи на основе порога амплитуды ЭМГ, интервалов между эвентами и безартефактности взятого окна ЭЭГ
emg_windows = resonance.pipe.windowizer(emg_Notch_HPFiltered, 50, 50)#шинкуем ЭМГ на мелкие окна
emg_as_events = resonance.pipe.transform_to_event(emg_windows, makeEvent)
intervalEvtToEvtInSec = 2.9
evt1 = GetEventsForTargetedEpochs(thresholdForEMGInVolts, intervalEvtToEvtInSec)#экземпляр получит значение, только в режиме NeedEpoching
cndtnlEMGEvtForTargetEpochs = resonance.pipe.filter_event(emg_as_events, evt1)#фильтранули событие по амплитуде ЭМГ и интервалам между событиями
#resonance.createOutput(cndtnlEvtForTargetEpochs, 'EvtCndtnlForTargetEpochs')
eeg_wndwzd = resonance.cross.windowize_by_events(eeg_Filtered_Referenced, cndtnlEMGEvtForTargetEpochs, window_size, window_shift)
#baselinedEpoch_ = resonance.pipe.baseline(eeg_wndwzd, slice(baseline_begin_offset, baseline_end_offset))
EvtsMaxAmplitudes = resonance.pipe.transform_to_event(eeg_wndwzd, makeEvent) # считаем максимумы амплитуд во взятых окнах
evt2 = CheckEvtsForAmplitudeThreshold(thresholdForEEGInVolts)#экземпляр получит значение, только в режиме NeedEpoching
cndtnlEvtForTargetEpochs = resonance.pipe.filter_event(EvtsMaxAmplitudes, evt2)#оставляем эвенты только тех окон, которые проходят по порогу интервалов
#берём окна для целевых эпох по отфильтрованным событиям (просмотр максимумов амплитуд (отбрасывание артефактных окон) по всему окну)
eeg_wndwzd_ = resonance.cross.windowize_by_events(eeg_Filtered_Referenced, cndtnlEvtForTargetEpochs, window_size, window_shift)
baselinedEpoch_ = resonance.pipe.baseline(eeg_wndwzd_, slice(baseline_begin_offset, baseline_end_offset))
#поскольку визуализации объекта окон пока нет, то преобразуем к эвенту чтобы посмотреть выхлоп во вьювере
exhaustEvt = resonance.pipe.transform_to_event(baselinedEpoch_, makeEvtAndAddTargetEpochToList)
resonance.createOutput(exhaustEvt, 'TargetEpochEvt')
def online_processing_0():
import resonance
import resonance.pipe
import scipy.signal as sp_sig
eeg = resonance.input(0)
cut_off_frequency = 30 # change this to 3 to suppress signal
low_pass_filter = sp_sig.butter(4,
cut_off_frequency / eeg.SI.samplingRate *
2,
btype='low')
eeg_filtered = resonance.pipe.filter(eeg, low_pass_filter)
resonance.createOutput(eeg_filtered, 'out')
def online_processing_3():
import resonance.pipe
import scipy.signal as sp_sig
eeg = resonance.input(0)
cut_off_frequency = 30
low_pass_filter = sp_sig.butter(4, cut_off_frequency / eeg.SI.samplingRate * 2, btype='low')
# eeg_data = np.array(eeg)
'''
eeg_data = eeg[:, 0]
eeg_data = np.reshape(eeg_data, (eeg.shape[0], 1))
'''
eeg_filtered = resonance.pipe.filter(eeg, low_pass_filter)
# так можно сделать расчёт референта, например
spatial_filter = np.eye(eeg_filtered.SI.channels) # единичная матрица
# [ 1 0 0 ]
# [ 0 1 0 ]
# [ 0 0 1 ]
spatial_filter[0, ...] = -1 # первый канал вычитаем из остальных
# пример, если каналы - строки
# [-1 0 0 ]
# [-1 1 0 ]
# [-1 0 1 ]
# если каналы - столбцы, как у нас, то
# [-1 -1 -1 ]
# [ 0 1 0 ]
# [ 0 0 1 ]
spatial_filter = spatial_filter[..., 1:] # первый канал это референт, убираем его из списка каналов
# пример, если каналы - строки
# [-1 1 0 ]
# [-1 0 1 ]
# если каналы - столбцы, как у нас, то
# [-1 -1 ]
# [ 1 0 ]
# [ 0 1 ]
eeg_referenced = resonance.pipe.spatial(eeg_filtered, spatial_filter)
events = resonance.input(1)
window_size = 250
eeg_windowized = resonance.cross.windowize_by_events(eeg_referenced, events, window_size)
baseline_begin_offset = 0
baseline_end_offset = 250
baselined = resonance.pipe.baseline(eeg_windowized, slice(baseline_begin_offset, baseline_end_offset))
baselined = baselined + 10
resonance.createOutput(baselined, 'out')
def online_processing_2():
eeg = resonance.input(0)
cut_off_frequency = 30
low_pass_filter = sp_sig.butter(4, cut_off_frequency / eeg.SI.samplingRate * 2, btype='low')
eeg_filtered = resonance.pipe.filter(eeg, low_pass_filter)
events = resonance.input(1)
window_size = 500
window_shift = -window_size
eeg_windowized = resonance.cross.windowize_by_events(eeg_filtered, events, window_size, window_shift)
baselined = resonance.pipe.baseline(eeg_windowized)
result = resonance.pipe.transform_to_event(baselined, makeEvent)
resonance.createOutput(result, 'out')
def online_processing_6():
import resonance.pipe
import scipy.signal as sp_sig
allData = resonance.input(0)
events = resonance.input(1)
np_eye = np.eye(allData.SI.channels) # единичная матрица - основа пространственной фильтрации
sptl_filtr0 = np_eye[...,:-1] # 2 последний канал - эвентный канал, убираем его из списка каналов (убираем из единичной матрицы крайний столбец)
woEvtChnlData = resonance.pipe.spatial(allData, sptl_filtr0)
bandstop_frequency = 50 # применяем режектор 50Гц для всех данных, кроме эвентного канала
w0 = [(bandstop_frequency - 0.5) / (allData.SI.samplingRate / 2),
(bandstop_frequency + 0.5) / (allData.SI.samplingRate / 2)]
bandstop_filter = sp_sig.butter(4, w0, btype='bandstop')
woEvtChnldata_Notchfiltered = resonance.pipe.filter(woEvtChnlData, bandstop_filter)
resonance.createOutput(woEvtChnldata_Notchfiltered, 'AllData_Notch_Filtered')
np_eye2 = np.eye(allData.SI.channels - 1) # единичная матрица для всех каналов минус эвентный канал
sptl_filtr = np_eye2[...,:-1] # оставляем только ЭЭГ, убираем последний канал - это ЭМГ (убираем из единичной матрицы крайний столбец)
eegData = resonance.pipe.spatial(woEvtChnldata_Notchfiltered, sptl_filtr)
sptl_filtr2 = np_eye2[..., -1:] # оставляем последний столбец - для отдельной фильтрации ЭМГ канала
emgData = resonance.pipe.spatial(woEvtChnldata_Notchfiltered, sptl_filtr2)
cut_off_frequency = 35
low_pass_filter = sp_sig.butter(4, cut_off_frequency / allData.SI.samplingRate * 2, btype='low')
eeg_LPfiltered = resonance.pipe.filter(eegData, low_pass_filter)
resonance.createOutput(eeg_LPfiltered, 'EEG_Notch_LP_Filtered')
highpass_frequency = 0.1
highpass_filter = sp_sig.butter(4, highpass_frequency, 'hp', fs=allData.SI.samplingRate)
eeg_LPHPfiltered = resonance.pipe.filter(eeg_LPfiltered, highpass_filter)
resonance.createOutput(eeg_LPHPfiltered, 'EEG_Notch_LP_HPFiltered')
# уже фильтрованную ЭЭГ корректируем на референт, в качестве которого возьмём 1й канал
np_eye3 = np.eye(allData.SI.channels - 2) # единичная матрица для всех каналов минус эвентный канал и минус ЭМГ
np_eye3[0, ...] = -1 # готовим матрицу, чтобы 1й канал вычесть из остальных (нулевая строка = -1)
sptl_filtr4 = np_eye3[...,1:] # первый канал - это референт, убираем его из списка каналов (Убираем первый столбец матрицы)
eeg_Filtered_Referenced = resonance.pipe.spatial(eeg_LPHPfiltered, sptl_filtr4)
resonance.createOutput(eeg_Filtered_Referenced, 'EEG_Filtered_Referenced')
# для ЭМГ применим только фильтр высоких частот
highpass_frequency = 5
highpass_filter = sp_sig.butter(4, highpass_frequency, 'hp', fs=allData.SI.samplingRate)
emg_HPfiltered = resonance.pipe.filter(emgData, highpass_filter)
resonance.createOutput(emg_HPfiltered, 'EMG_Notch_HPFiltered')
def online_processing_5():
import numpy as np
eeg = resonance.input(0)
eeg_windows = resonance.pipe.windowizer(eeg, 10, 10)
# ts = np.array(eeg_windows.timestamps)
# ts2 = eeg.TS
# np.savetxt('d:/Projects/BCI_EyeLines_Online_2020/rpe/test.txt', ts2)
# eeg_windows = np.array(eeg_windows)
as_events = resonance.pipe.transform_to_event(eeg_windows, makeEvent)
# as_events = np.array(as_events)
#conditional = resonance.pipe.filter_event(as_events, lambda evt: float(evt) > 0)
evt = ConditionalEventNotTooOften(0, 2)
conditional = resonance.pipe.filter_event(as_events, evt)
resonance.createOutput(conditional, 'out')
def online_processing_0():
import resonance
import resonance.pipe
import scipy.signal as sp_sig
eeg = resonance.input(0)
cut_off_frequency = 35 # change this to 3 to suppress signal
# low_pass_filter = sp_sig.butter(4, cut_off_frequency / eeg.SI.samplingRate * 2, btype='low')
'''
bandstop_frequency = 50
w0 = [(bandstop_frequency - 0.5) / (eeg.SI.samplingRate / 2), (bandstop_frequency + 0.5) / (eeg.SI.samplingRate / 2)]
bandstop_filter = sp_sig.butter(4, w0, btype='bandstop')
eeg_filtered = resonance.pipe.filter(eeg, bandstop_filter)
resonance.createOutput(eeg_filtered, 'out')
'''
highpass_frequency = 0.1
highpass_filter = sp_sig.butter(4, highpass_frequency, 'hp', fs=eeg.SI.samplingRate)
eeg_filtered = resonance.pipe.filter(eeg, highpass_filter)
resonance.createOutput(eeg_filtered, 'out')
def online_processing_4_1():
eeg = resonance.input(0)
events = resonance.input(1)
cmd1 = resonance.pipe.filter_event(events, SetWorkState)
resonance.createOutput(cmd1, 'EvtWorkState')
eeg_windows = resonance.pipe.windowizer(eeg, 10, 10)
as_events = resonance.pipe.transform_to_event(eeg_windows, makeEvent)
evt = ConditionalEventNotTooOften2(0, 2)
conditional = resonance.pipe.filter_event(as_events, evt)
#resonance.createOutput(conditional, 'Evtout')
window_size = 50
window_shift = -50
baseline_begin_offset = 0
baseline_end_offset = 50
eeg_windowized = resonance.cross.windowize_by_events(eeg, conditional, window_size, window_shift)
baselined = resonance.pipe.baseline(eeg_windowized, slice(baseline_begin_offset, baseline_end_offset))
result_ = resonance.pipe.transform_to_event(baselined, makeEvent)
resonance.createOutput(result_, 'Evtout')
def online_processing_5():
import resonance.pipe
import scipy.signal as sp_sig
eeg = resonance.input(0)
events = resonance.input(1)
cut_off_frequency = 30
low_pass_filter = sp_sig.butter(4,
cut_off_frequency / eeg.SI.samplingRate *
2,
btype='low')
eeg_filtered = resonance.pipe.filter(eeg, low_pass_filter)
resonance.createOutput(eeg_filtered, 'data_filtered')
# берём целевую эпоху, если значение выше порога по каналу ЭМГ
window_size = 500
window_shift = -500
baseline_begin_offset = 0
baseline_end_offset = 250
def interleave_blocks(blocks):
return sorted(blocks, key=lambda x: x.TS[0])
events_si = resonance.si.Event()
ts = eeg.TS
events_ = [resonance.db.Event(events_si, 10.4e9, '1')]
data_ = interleave_blocks(eeg_filtered + events_)
eeg_windowized = resonance.cross.windowize_by_events(
data_, events, window_size, window_shift)
baselined = resonance.pipe.baseline(
eeg_windowized, slice(baseline_begin_offset, baseline_end_offset))
result_ = resonance.pipe.transform_to_event(baselined, makeEvent)
resonance.createOutput(result_, 'Evtout2')
def online_processing_4():
import resonance.pipe
import scipy.signal as sp_sig
eeg = resonance.input(0)
events = resonance.input(1)
'''
с фильтрами надо позже разобраться. Постоянку чем резать, пока не понятно
и нужен ли 50Гц режектор, если полоса ограничена 25Гц, скажем?
'''
cut_off_frequency = 25
low_pass_filter = sp_sig.butter(4,
cut_off_frequency / eeg.SI.samplingRate *
2,
btype='low')
eeg_filtered = resonance.pipe.filter(eeg, low_pass_filter)
resonance.createOutput(eeg_filtered, 'out')
window_size = 500
window_shift = -250
baseline_begin_offset = 0
baseline_end_offset = 250
def rule1(evt):
return evt == "1"
def rule2(evt):
return evt == "2"
cmd1 = resonance.pipe.filter_event(events, rule1)
resonance.createOutput(cmd1, 'Evtout1')
cmd2 = resonance.pipe.filter_event(events, rule2)
eeg_windowized = resonance.cross.windowize_by_events(
eeg_filtered, cmd2, window_size, window_shift)
baselined = resonance.pipe.baseline(
eeg_windowized, slice(baseline_begin_offset, baseline_end_offset))
result_ = resonance.pipe.transform_to_event(baselined, makeEvent)
resonance.createOutput(result_, 'Evtout2')
cmd3 = resonance.pipe.filter_event(
events, lambda evt: not (rule1(evt) or rule2(evt)))
resonance.createOutput(cmd3, 'Evtout3')
def code():
resonance.createOutput(resonance.input(0), 'out')
def call():
resonance.createOutput(resonance.input(0), 'func')