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_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 test_ecg_intervalrelated():
data = nk.data("bio_resting_5min_100hz")
df, info = nk.ecg_process(data["ECG"], sampling_rate=100)
columns = [
'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'
]
# Test with signal dataframe
features_df = nk.ecg_intervalrelated(df)
assert all(elem in columns
for elem in np.array(features_df.columns.values, dtype=str))
assert features_df.shape[0] == 1 # Number of rows
# Test with dict
epochs = nk.epochs_create(df,
events=[0, 15000],
sampling_rate=100,
epochs_end=150)
features_dict = nk.ecg_intervalrelated(epochs, sampling_rate=100)
assert all(elem in columns
for elem in np.array(features_dict.columns.values, dtype=str))
assert features_dict.shape[0] == 2 # Number of rows
def test_eog_clean():
# test with exported csv
eog_signal = nk.data("eog_200hz")["vEOG"]
eog_cleaned = nk.eog_clean(eog_signal, sampling_rate=200)
assert eog_cleaned.size == eog_signal.size
# test with mne.io.Raw
raw = mne.io.read_raw_fif(mne.datasets.sample.data_path() +
"/MEG/sample/sample_audvis_raw.fif",
preload=True)
sampling_rate = raw.info["sfreq"]
eog_channels = nk.mne_channel_extract(raw, what="EOG", name="EOG")
eog_cleaned = nk.eog_clean(eog_channels,
sampling_rate,
method="agarwal2019")
assert eog_cleaned.size == eog_channels.size
# compare with mne filter
eog_cleaned_mne = nk.eog_clean(eog_channels, sampling_rate, method="mne")
mne_clean = mne.filter.filter_data(
eog_channels,
sfreq=sampling_rate,
l_freq=1,
h_freq=10,
filter_length="10s",
l_trans_bandwidth=0.5,
h_trans_bandwidth=0.5,
phase="zero-double",
fir_window="hann",
fir_design="firwin2",
verbose=False,
)
assert np.allclose((eog_cleaned_mne - mne_clean).mean(), 0)
def test_eog_findpeaks():
eog_signal = nk.data('eog_100hz')
eog_cleaned = nk.eog_clean(eog_signal, sampling_rate=100)
# Test with Neurokit
nk_peaks = nk.eog_findpeaks(eog_cleaned,
sampling_rate=100,
method="neurokit",
threshold=0.33,
show=False)
assert nk_peaks.size == 19
# Test with MNE
mne_peaks = nk.eog_findpeaks(eog_cleaned, method="mne")
assert mne_peaks.size == 44
# Test with brainstorm
brainstorm_peaks = nk.eog_findpeaks(eog_cleaned, method="brainstorm")
assert brainstorm_peaks.size == 28
blinker_peaks = nk.eog_findpeaks(eog_cleaned,
method="blinker",
sampling_rate=100)
assert blinker_peaks.size == 14
def test_eog_plot():
eog_signal = nk.data("eog_100hz")
signals, info = nk.eog_process(eog_signal, sampling_rate=100)
# Plot
nk.eog_plot(signals, peaks=info, sampling_rate=100)
fig = plt.gcf()
assert len(fig.axes) == 3
titles = ["Raw and Cleaned Signal", "Blink Rate", "Individual Blinks"]
legends = [["Raw", "Cleaned", "Blinks"], ["Rate", "Mean"], ["Median"]]
ylabels = ["Amplitude (mV)", "Blinks per minute"]
for (ax, title, legend, ylabel) in zip(fig.get_axes(), titles, legends,
ylabels):
assert ax.get_title() == title
subplot = ax.get_legend_handles_labels()
assert subplot[1] == legend
assert ax.get_ylabel() == ylabel
assert fig.get_axes()[1].get_xlabel() == "Time (seconds)"
np.testing.assert_array_equal(fig.axes[0].get_xticks(),
fig.axes[1].get_xticks())
plt.close(fig)
with pytest.raises(ValueError, match=r'NeuroKit error: eog_plot.*'):
nk.eog_plot(None)
def test_eog_process():
eog_signal = nk.data("eog_200hz")["vEOG"]
signals, info = nk.eog_process(eog_signal, sampling_rate=200)
# Extract blinks, test across dataframe and dict
blinks = np.where(signals["EOG_Blinks"] == 1)[0]
assert np.all(blinks == info["EOG_Blinks"])
def Get_ECG():
# Retrieve ECG data from NeuroKit
print()
print()
print(
"======== Retrieving ECG Signal Data Set ========")
ecg_signal = nk.data(dataset="ecg_3000hz")['ECG']
return ecg_signal
def test_data():
dataset="bio_eventrelated_100hz"
data = nk.data(dataset)
assert len(data.columns) == 4
assert data.size == 15000*4
assert all(elem in ['ECG', 'EDA', 'Photosensor', 'RSP']
for elem in np.array(data.columns.values, dtype=str))
dataset2="bio_eventrelated_100hz.csv"
data2 = nk.data(dataset2)
assert len(data.columns) == len(data2.columns)
assert data2.size == data.size
assert all(elem in np.array(data.columns.values, dtype=str)
for elem in np.array(data2.columns.values, dtype=str))
def loadRealdata():
# Download example data
data = nk.data("bio_eventrelated_100hz")
# Preprocess the data (filter, find peaks, etc.)
processed_data, info = nk.bio_process(ecg=data["ECG"], rsp=data["RSP"], eda=data["EDA"], sampling_rate=100)
# Compute relevant features
results = nk.bio_analyze(processed_data, sampling_rate=100)
def test_signal_psd(recwarn):
warnings.simplefilter("always")
data = nk.data("bio_eventrelated_100hz")
out = nk.signal_psd(data["ECG"], sampling_rate=100)
assert list(out.columns) == ["Frequency", "Power"]
assert len(recwarn) == 1
assert recwarn.pop(nk.misc.NeuroKitWarning)
def test_rsp_intervalrelated():
data = nk.data("bio_resting_5min_100hz")
df, info = nk.rsp_process(data["RSP"], sampling_rate=100)
# Test with signal dataframe
features_df = nk.rsp_intervalrelated(df)
assert features_df.shape[0] == 1 # Number of rows
# Test with dict
epochs = nk.epochs_create(df,
events=[0, 15000],
sampling_rate=100,
epochs_end=150)
features_dict = nk.rsp_intervalrelated(epochs)
assert features_dict.shape[0] == 2 # Number of rows
def test_hrv_rsa():
data = nk.data("bio_eventrelated_100hz")
ecg_signals, info = nk.ecg_process(data["ECG"], sampling_rate=100)
rsp_signals, _ = nk.rsp_process(data["RSP"], sampling_rate=100)
rsa_feature_columns = [
'RSA_P2T_Mean', 'RSA_P2T_Mean_log', 'RSA_P2T_SD', 'RSA_P2T_NoRSA',
'RSA_PorgesBohrer', 'RSA_Gates_Mean', 'RSA_Gates_Mean_log',
'RSA_Gates_SD'
]
rsa_features = nk.hrv_rsa(ecg_signals,
rsp_signals,
rpeaks=info,
sampling_rate=100,
continuous=False)
assert all(key in rsa_feature_columns for key in rsa_features.keys())
# Test simulate RSP signal warning
with pytest.warns(misc.NeuroKitWarning,
match=r"RSP signal not found. For this.*"):
nk.hrv_rsa(ecg_signals,
rpeaks=info,
sampling_rate=100,
continuous=False)
with pytest.warns(misc.NeuroKitWarning,
match=r"RSP signal not found. RSP signal.*"):
nk.hrv_rsa(ecg_signals,
pd.DataFrame(),
rpeaks=info,
sampling_rate=100,
continuous=False)
# Test missing rsp onsets/centers
with pytest.warns(misc.NeuroKitWarning,
match=r"Couldn't find rsp cycles onsets and centers.*"):
rsp_signals["RSP_Peaks"] = 0
nk.hrv_rsa(ecg_signals,
rsp_signals,
rpeaks=info,
sampling_rate=100,
continuous=False)
def test_eda_intervalrelated():
data = nk.data("bio_resting_8min_100hz")
df, info = nk.eda_process(data["EDA"], sampling_rate=100)
columns = ['SCR_Peaks_N', 'SCR_Peaks_Amplitude_Mean']
# Test with signal dataframe
features_df = nk.eda_intervalrelated(df)
assert all(elem in columns for elem
in np.array(features_df.columns.values, dtype=str))
assert features_df.shape[0] == 1 # Number of rows
# Test with dict
epochs = nk.epochs_create(df, events=[0, 25300],
sampling_rate=100, epochs_end=20)
features_dict = nk.eda_intervalrelated(epochs)
assert all(elem in columns for elem
in np.array(features_dict.columns.values, dtype=str))
assert features_dict.shape[0] == 2 # Number of rows
def test_ecg_intervalrelated():
data = nk.data("bio_resting_5min_100hz")
df, info = nk.ecg_process(data["ECG"], sampling_rate=100)
columns = [
'ECG_Rate_Mean', 'HRV_RMSSD', 'HRV_MeanNN', 'HRV_SDNN', 'HRV_SDSD',
'HRV_CVNN', 'HRV_CVSD', 'HRV_MedianNN', 'HRV_MadNN', 'HRV_MCVNN',
'HRV_IQRNN', '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_SD1SD2',
'HRV_S', 'HRV_CSI', 'HRV_CVI', 'HRV_CSI_Modified', 'HRV_PIP',
'HRV_IALS', 'HRV_PSS', 'HRV_PAS', 'HRV_ApEn', 'HRV_SampEn', 'HRV_GI',
'HRV_SI', 'HRV_AI', 'HRV_PI', 'HRV_C1d', 'HRV_C1a', 'HRV_SD1d',
'HRV_SD1a', 'HRV_C2d', 'HRV_C2a', 'HRV_SD2d', 'HRV_SD2a', 'HRV_Cd',
'HRV_Ca', 'HRV_SDNNd', 'HRV_SDNNa'
]
# Test with signal dataframe
features_df = nk.ecg_intervalrelated(df, sampling_rate=100)
# https://github.com/neuropsychology/NeuroKit/issues/304
assert all(features_df == nk.ecg_analyze(
df, sampling_rate=100, method="interval-related"))
assert all(elem in np.array(features_df.columns.values, dtype=str)
for elem in columns)
assert features_df.shape[0] == 1 # Number of rows
# Test with dict
epochs = nk.epochs_create(df,
events=[0, 15000],
sampling_rate=100,
epochs_end=150)
features_dict = nk.ecg_intervalrelated(epochs, sampling_rate=100)
assert all(elem in columns
for elem in np.array(features_dict.columns.values, dtype=str))
assert features_dict.shape[0] == 2 # Number of rows
def test_eog_eventrelated():
eog = nk.data('eog_200hz')['vEOG']
eog_signals, info = nk.eog_process(eog, sampling_rate=200)
epochs = nk.epochs_create(eog_signals,
events=[5000, 10000, 15000],
epochs_start=-0.1,
epochs_end=1.9)
eog_eventrelated = nk.eog_eventrelated(epochs)
# Test rate features
assert np.alltrue(
np.array(eog_eventrelated["EOG_Rate_Min"]) < np.array(
eog_eventrelated["EOG_Rate_Mean"]))
assert np.alltrue(
np.array(eog_eventrelated["EOG_Rate_Mean"]) < np.array(
eog_eventrelated["EOG_Rate_Max"]))
# Test blink presence
assert np.alltrue(
np.array(eog_eventrelated["EOG_Blinks_Presence"]) == np.array(
[1, 0, 0]))
# Test warning on missing columns
with pytest.warns(nk.misc.NeuroKitWarning,
match=r".*does not have an `EOG_Blinks`.*"):
first_epoch_key = list(epochs.keys())[0]
first_epoch_copy = epochs[first_epoch_key].copy()
del first_epoch_copy["EOG_Blinks"]
nk.eog_eventrelated({**epochs, first_epoch_key: first_epoch_copy})
with pytest.warns(nk.misc.NeuroKitWarning,
match=r".*does not have an `EOG_Rate`.*"):
first_epoch_key = list(epochs.keys())[0]
first_epoch_copy = epochs[first_epoch_key].copy()
del first_epoch_copy["EOG_Rate"]
nk.eog_eventrelated({**epochs, first_epoch_key: first_epoch_copy})
def test_eog_eventrelated():
eog = nk.data('eog_200hz')['vEOG']
eog_signals, info = nk.eog_process(eog, sampling_rate=200)
epochs = nk.epochs_create(eog_signals,
events=[5000, 10000, 15000],
epochs_start=-0.1,
epochs_end=1.9)
eog_eventrelated = nk.eog_eventrelated(epochs)
# Test rate features
assert np.alltrue(
np.array(eog_eventrelated["EOG_Rate_Min"]) < np.array(
eog_eventrelated["EOG_Rate_Mean"]))
assert np.alltrue(
np.array(eog_eventrelated["EOG_Rate_Mean"]) < np.array(
eog_eventrelated["EOG_Rate_Max"]))
# Test blink presence
assert np.alltrue(
np.array(eog_eventrelated["EOG_Blinks_Presence"]) == np.array(
[1, 0, 0]))
def test_rsp_intervalrelated():
data = nk.data("bio_resting_5min_100hz")
df, info = nk.rsp_process(data["RSP"], sampling_rate=100)
columns = ['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']
# Test with signal dataframe
features_df = nk.rsp_intervalrelated(df)
assert all(elem in columns for elem
in np.array(features_df.columns.values, dtype=str))
assert features_df.shape[0] == 1 # Number of rows
# Test with dict
epochs = nk.epochs_create(df, events=[0, 15000],
sampling_rate=100, epochs_end=150)
features_dict = nk.rsp_intervalrelated(epochs)
assert all(elem in columns for elem
in np.array(features_dict.columns.values, dtype=str))
assert features_dict.shape[0] == 2 # Number of rows
def test_eog_intervalrelated():
eog = nk.data('eog_200hz')['vEOG']
eog_signals, info = nk.eog_process(eog, sampling_rate=200)
columns = ['EOG_Peaks_N', 'EOG_Rate_Mean']
# Test with signal dataframe
features = nk.eog_intervalrelated(eog_signals)
assert all(elem in np.array(features.columns.values, dtype=str)
for elem in columns)
assert features.shape[0] == 1 # Number of rows
# Test with dict
epochs = nk.epochs_create(eog_signals,
events=[5000, 10000, 15000],
epochs_start=-0.1,
epochs_end=1.9)
epochs_dict = nk.eog_intervalrelated(epochs)
assert all(elem in columns
for elem in np.array(epochs_dict.columns.values, dtype=str))
assert epochs_dict.shape[0] == len(epochs) # Number of rows
import pandas as pd
import matplotlib
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import matplotlib.cm
import neurokit2 as nk
# setup matplotlib with Agg to run on server
matplotlib.use('Agg')
# =============================================================================
# Quick Example
# =============================================================================
# Download example data
data = nk.data("bio_eventrelated_100hz")
# Preprocess the data (filter, find peaks, etc.)
processed_data, info = nk.bio_process(ecg=data["ECG"],
rsp=data["RSP"],
eda=data["EDA"],
sampling_rate=100)
# Compute relevant features
results = nk.bio_analyze(processed_data, sampling_rate=100)
# =============================================================================
# Simulate physiological signals
# =============================================================================
# Generate synthetic signals
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import neurokit2 as nk
# =============================================================================
# Quick Example
# =============================================================================
# Download example data
data = nk.data("bio_eventrelated_100hz")
# Preprocess the data (filter, find peaks, etc.)
processed_data, info = nk.bio_process(ecg=data["ECG"],
rsp=data["RSP"],
eda=data["EDA"],
sampling_rate=100)
# Compute relevant features
results = nk.bio_analyze(processed_data, sampling_rate=100)
# =============================================================================
# Simulate physiological signals
# =============================================================================
# Generate synthetic signals
ecg = nk.ecg_simulate(duration=10, heart_rate=70)
ppg = nk.ppg_simulate(duration=10, heart_rate=70)
rsp = nk.rsp_simulate(duration=10, respiratory_rate=15)
eda = nk.eda_simulate(duration=10, scr_number=3)
emg = nk.emg_simulate(duration=10, burst_number=2)
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import neurokit2 as nk
# =============================================================================
# Quick Example
# =============================================================================
# Download example data
data = nk.data("bio_eventrelated_100hz")
# Preprocess the data (filter, find peaks, etc.)
processed_data, info = nk.bio_process(ecg=data["ECG"],
rsp=data["RSP"],
eda=data["EDA"],
sampling_rate=100)
# Compute relevant features
results = nk.bio_analyze(processed_data, sampling_rate=100)
# =============================================================================
# Simulate physiological signals
# =============================================================================
# Generate synthetic signals
ecg = nk.ecg_simulate(duration=10, heart_rate=70)
ppg = nk.ppg_simulate(duration=10, heart_rate=70)
rsp = nk.rsp_simulate(duration=10, respiratory_rate=15)
eda = nk.eda_simulate(duration=10, scr_number=3)
emg = nk.emg_simulate(duration=10, burst_number=2)
