def test_events_plot():
signal = np.cos(np.linspace(start=0, stop=20, num=1000))
events = nk.events_find(signal)
data = nk.events_plot(events, signal, show=False)
assert len(data["Event_Onset"]) == 1000
# Different events
events1 = events["onset"]
events2 = np.linspace(0, len(signal), 8)
nk.events_plot([events1, events2], signal)
fig = plt.gcf()
for ax in fig.get_axes():
handles, labels = ax.get_legend_handles_labels()
assert len(handles) == len(events1) + len(events2) + 1
assert len(labels) == len(handles)
plt.close(fig)
# Different conditions
events = nk.events_find(signal, event_conditions=["A", "B", "A", "B"])
nk.events_plot(events, signal)
fig = plt.gcf()
for ax in fig.get_axes():
handles, labels = ax.get_legend_handles_labels()
assert len(handles) == len(events) + 1
assert len(labels) == len(handles)
plt.close(fig)
def test_events_find():
signal = np.cos(np.linspace(start=0, stop=20, num=1000))
events = nk.events_find(signal)
assert list(events["onset"]) == [0, 236, 550, 864]
events = nk.events_find(signal, duration_min=150)
assert list(events["onset"]) == [236, 550]
events = nk.events_find(signal, inter_min=300)
assert list(events["onset"]) == [0, 550, 864]
def test_bio_analyze():
# Example with event-related analysis
data = nk.data("bio_eventrelated_100hz")
df, info = nk.bio_process(ecg=data["ECG"],
rsp=data["RSP"],
eda=data["EDA"],
keep=data["Photosensor"],
sampling_rate=100)
events = nk.events_find(
data["Photosensor"],
threshold_keep="below",
event_conditions=["Negative", "Neutral", "Neutral", "Negative"])
epochs = nk.epochs_create(df,
events,
sampling_rate=100,
epochs_start=-0.1,
epochs_end=1.9)
event_related = nk.bio_analyze(epochs)
assert len(event_related) == len(epochs)
labels = [int(i) for i in event_related["Label"]]
assert labels == list(np.arange(1, len(epochs) + 1))
# Example with interval-related analysis
data = nk.data("bio_resting_8min_100hz")
df, info = nk.bio_process(ecg=data["ECG"],
rsp=data["RSP"],
eda=data["EDA"],
sampling_rate=100)
interval_related = nk.bio_analyze(df)
assert len(interval_related) == 1
def test_events_find():
signal = np.cos(np.linspace(start=0, stop=20, num=1000))
events = nk.events_find(signal)
assert list(events["onset"]) == [0, 236, 550, 864]
events = nk.events_find(signal, duration_min=150)
assert list(events["onset"]) == [236, 550]
events = nk.events_find(signal, inter_min=300)
assert list(events["onset"]) == [0, 550, 864]
# No events found warning
signal = np.zeros(1000)
with pytest.warns(nk.misc.NeuroKitWarning, match=r'No events found.*'):
nk.events_find(signal)
def test_bio_analyze():
# Example with event-related analysis
data = nk.data("bio_eventrelated_100hz")
df, info = nk.bio_process(ecg=data["ECG"],
rsp=data["RSP"],
eda=data["EDA"],
keep=data["Photosensor"],
sampling_rate=100)
events = nk.events_find(
data["Photosensor"],
threshold_keep='below',
event_conditions=["Negative", "Neutral", "Neutral", "Negative"])
epochs = nk.epochs_create(df,
events,
sampling_rate=100,
epochs_start=-0.1,
epochs_end=1.9)
event_related = nk.bio_analyze(epochs)
assert len(event_related) == len(epochs)
labels = [int(i) for i in event_related['Label']]
assert labels == list(np.arange(1, len(epochs) + 1))
assert all(elem in [
'ECG_Rate_Max', 'ECG_Rate_Min', 'ECG_Rate_Mean', 'ECG_Rate_Max_Time',
'ECG_Rate_Min_Time', 'ECG_Rate_Trend_Quadratic',
'ECG_Rate_Trend_Linear', 'ECG_Rate_Trend_R2', 'ECG_Atrial_Phase',
'ECG_Atrial_PhaseCompletion', 'ECG_Ventricular_Phase',
'ECG_Ventricular_PhaseCompletion', 'ECG_Quality_Mean', 'RSP_Rate_Max',
'RSP_Rate_Min', 'RSP_Rate_Mean', 'RSP_Rate_Max_Time',
'RSP_Rate_Min_Time', 'RSP_Amplitude_Max', 'RSP_Amplitude_Min',
'RSP_Amplitude_Mean', 'RSP_Phase', 'RSP_PhaseCompletion', 'EDA_SCR',
'EDA_Peak_Amplitude', 'SCR_Peak_Amplitude', 'SCR_Peak_Amplitude_Time',
'SCR_RiseTime', 'SCR_RecoveryTime', 'RSA_P2T', 'Label', 'Condition'
] for elem in np.array(event_related.columns.values, dtype=str))
# Example with interval-related analysis
data = nk.data("bio_resting_8min_100hz")
df, info = nk.bio_process(ecg=data["ECG"],
rsp=data["RSP"],
eda=data["EDA"],
sampling_rate=100)
interval_related = nk.bio_analyze(df)
assert len(interval_related) == 1
assert all(elem in [
'ECG_Rate_Mean', 'HRV_RMSSD', 'HRV_MeanNN', 'HRV_SDNN', 'HRV_SDSD',
'HRV_CVNN', 'HRV_CVSD', 'HRV_MedianNN', 'HRV_MadNN', 'HRV_MCVNN',
'HRV_pNN50', 'HRV_pNN20', 'HRV_TINN', 'HRV_HTI', 'HRV_ULF', 'HRV_VLF',
'HRV_LF', 'HRV_HF', 'HRV_VHF', 'HRV_LFHF', 'HRV_LFn', 'HRV_HFn',
'HRV_LnHF', 'HRV_SD1', 'HRV_SD2', 'HRV_SD2SD1', 'HRV_CSI', 'HRV_CVI',
'HRV_CSI_Modified', 'HRV_SampEn', 'RSP_Rate_Mean',
'RSP_Amplitude_Mean', 'RRV_SDBB', 'RRV_RMSSD', 'RRV_SDSD', 'RRV_VLF',
'RRV_LF', 'RRV_HF', 'RRV_LFHF', 'RRV_LFn', 'RRV_HFn', 'RRV_SD1',
'RRV_SD2', 'RRV_SD2SD1', 'RRV_ApEn', 'RRV_SampEn', 'RRV_DFA',
'RSA_P2T_Mean', 'RSA_P2T_Mean_log', 'RSA_P2T_SD', 'RSA_P2T_NoRSA',
'RSA_PorgesBohrer', 'SCR_Peaks_N', 'SCR_Peaks_Amplitude_Mean'
] for elem in np.array(interval_related.columns.values, dtype=str))
def find_events(signals,
tag,
condition_list=None,
treshold_keep='below',
duration=1,
sample_rate=64):
"""
Create array of events (length: duration * sample_rate) marked by tag signal.
Parameters
----------
signals : Union [pd.DataFrame]
BVP and EDA signals.
tag : Union [pd.DataFrame]
Tag data from E4. Marked events by participant.
condition_list : list
Emotions for each epoch. Length must be the same as tag length.
treshold_keep : str ['below', 'above']
Parameter for 'events_find' function.
duration : int
Set length of event.
sample_rate : int
Sample rate of signals (must be same for all signals).
Returns
-------
dict
Dict of events (more info: https://neurokit2.readthedocs.io/en/latest/functions.html#module-neurokit2.events).
{'onset': array(...),
'duration': array(...),
'label': array(...)}
"""
if tag.shape[0] != 0:
tag_signal = np.ones(signals.shape[0])
#For each marked event set value 0 for
#(duration * sample_rate) data points.
events_time = list(tag['norm_ts'])
for t in events_time:
end_t = int(t + duration) * sample_rate
t = int(t * sample_rate)
tag_signal[t:end_t] = 0
events = nk.events_find(event_channel=tag_signal,
threshold_keep=treshold_keep,
event_conditions=condition_list)
return events
import mne
import numpy as np
import TruScanEEGpy
import neurokit2 as nk
# Read original file (too big to be uploaded on github)
raw = mne.io.read_raw_edf("eeg_restingstate_3000hz.edf", preload=True)
# Find event onset and cut
event = nk.events_find(raw.copy().pick_channels(["Foto"
]).to_data_frame()["Foto"])
tmin = event["onset"][0] / 3000
raw = raw.crop(tmin=tmin, tmax=tmin + 8 * 60)
# EOG
eog = raw.copy().pick_channels(["124", "125"]).to_data_frame()
eog = eog["124"] - eog["125"]
raw = nk.eeg_add_channel(raw, eog, channel_type="eog", channel_name="EOG")
raw = raw.drop_channels(["124", "125"])
# Montage
mne.rename_channels(
raw.info,
dict(
zip(raw.info["ch_names"],
TruScanEEGpy.convert_to_tenfive(raw.info["ch_names"]))))
montage = TruScanEEGpy.montage_mne_128(TruScanEEGpy.layout_128(names="10-5"))
extra_channels = np.array(raw.info["ch_names"])[np.array(
[i not in montage.ch_names for i in raw.info["ch_names"]])]
raw = raw.drop_channels(extra_channels[np.array(
df_gsr.sort_index(inplace=True)
freq_gsr = pd.infer_freq(df_gsr.index)
#print("new freq: %s, gsr shape: %s" %(freq_gsr,df_gsr.shape))
freq_delta_gsr = pd.Timedelta(freq_gsr)
hz_gsr = 1 / freq_delta_gsr.total_seconds()
# extract events
df_event = pd.Series(index=df_gsr.index, data=0)
for event_raw_index in df_sc_trigger.index.values:
nearest_gsr_index = df_gsr.index.get_loc(
event_raw_index, method="nearest")
df_event[nearest_gsr_index] = df_sc_trigger[
event_raw_index]
# find events
eda_events = nk.events_find(df_event,
threshold=0,
threshold_keep='above')
# process eda signals
eda_signals, eda_info = nk.bio_process(
eda=df_gsr, sampling_rate=hz_gsr)
# create epochs
eda_epochs_end = sc_duration if (
sc_duration -
EPOCH_START) <= EPOCH_DURATION else (
EPOCH_START + EPOCH_DURATION)
eda_epochs = nk.epochs_create(
eda_signals,
eda_events,
sampling_rate=hz_gsr,
epochs_start=EPOCH_START,
epochs_end=eda_epochs_end)
def test_events_to_mne():
signal = np.cos(np.linspace(start=0, stop=20, num=1000))
events = nk.events_find(signal)
events, event_id = nk.events_to_mne(events)
assert event_id == {"event": 0}
def test_events_plot():
signal = np.cos(np.linspace(start=0, stop=20, num=1000))
events = nk.events_find(signal)
data = nk.events_plot(events, signal, show=False)
assert len(data['Event_Onset']) == 1000
def _check_events(raw):
event_channel = raw.copy().pick_channels(["Foto"]).to_data_frame()["Foto"]
events = nk.events_find(event_channel, inter_min=200, discard_last=1)
if len(events["Duration"]) != 60:
print("Warning: " + str(len(events["Duration"])) + " events")
return (events)
for i, file in enumerate(files[0:2]):
print(i)
# Read
raw = mne.io.read_raw_bdf(data_path + file,
eog=['LVEOG', 'RVEOG', 'LHEOG', 'RHEOG'],
misc=['M1', 'M2', 'NAS', 'NFpz'],
preload=True)
sampling_rate = np.rint(raw.info["sfreq"])
# Set montage
raw = raw.set_montage("biosemi64")
# Find events
events = nk.events_find(nk.mne_channel_extract(raw, "Status"),
threshold_keep="below",
event_conditions=["EyesClosed", "EyesOpen"] * 4)
# Rereference
raw = nk.eeg_rereference(raw, ["M1", "M2"])
# Filter
raw = raw.filter(1, 35)
# Bad epochs
bads, info = nk.eeg_badchannels(raw)
raw.info['bads'] += bads
# raw.plot()
raw = raw.interpolate_bads()
# ICA
