def preprocessing_and_feature_extraction_ECG(raw):#(file_name_csv,raw):
data_ECG={}
for participant in range(0,23):
for video in range(0,18):
# load raw baseline and stimuli data for left and right
basl_l=raw['DREAMER'][0,0]['Data'][0,participant]['ECG'][0,0]['baseline'][0,0][video,0][:,0]
stim_l=raw['DREAMER'][0,0]['Data'][0,participant]['ECG'][0,0]['stimuli'][0,0][video,0][:,0]
basl_r=raw['DREAMER'][0,0]['Data'][0,participant]['ECG'][0,0]['baseline'][0,0][video,0][:,1]
stim_r=raw['DREAMER'][0,0]['Data'][0,participant]['ECG'][0,0]['stimuli'][0,0][video,0][:,1]
# process with neurokit
ecg_signals_b_l,info_b_l=nk.ecg_process(basl_l,sampling_rate=256)
ecg_signals_s_l,info_s_l=nk.ecg_process(stim_l,sampling_rate=256)
ecg_signals_b_r,info_b_r=nk.ecg_process(basl_r,sampling_rate=256)
ecg_signals_s_r,info_s_r=nk.ecg_process(stim_r,sampling_rate=256)
# divide stimuli features by baseline features
# would be interesting to compare classification accuracy when we
# don't do this
features_ecg_l=nk.ecg_intervalrelated(ecg_signals_s_l)/nk.ecg_intervalrelated(ecg_signals_b_l)
features_ecg_r=nk.ecg_intervalrelated(ecg_signals_s_r)/nk.ecg_intervalrelated(ecg_signals_b_r)
# average left and right features
# would be interesting to compare classification accuracy when we
# rather include both left and right features
features_ecg=(features_ecg_l+features_ecg_r)/2
if not len(data_ECG):
data_ECG=features_ecg
else:
data_ECG=pd.concat([data_ECG,features_ecg],ignore_index=True)
return data_ECG
def test_hrv_time():
ecg_slow = nk.ecg_simulate(duration=60,
sampling_rate=1000,
heart_rate=70,
random_state=42)
ecg_fast = nk.ecg_simulate(duration=60,
sampling_rate=1000,
heart_rate=110,
random_state=42)
_, peaks_slow = nk.ecg_process(ecg_slow, sampling_rate=1000)
_, peaks_fast = nk.ecg_process(ecg_fast, sampling_rate=1000)
hrv_slow = nk.hrv_time(peaks_slow, sampling_rate=1000)
hrv_fast = nk.hrv_time(peaks_fast, sampling_rate=1000)
assert np.all(hrv_fast["HRV_RMSSD"] < hrv_slow["HRV_RMSSD"])
assert np.all(hrv_fast["HRV_MeanNN"] < hrv_slow["HRV_MeanNN"])
assert np.all(hrv_fast["HRV_SDNN"] < hrv_slow["HRV_SDNN"])
assert np.all(hrv_fast["HRV_CVNN"] < hrv_slow["HRV_CVNN"])
assert np.all(hrv_fast["HRV_CVSD"] < hrv_slow["HRV_CVSD"])
assert np.all(hrv_fast["HRV_MedianNN"] < hrv_slow["HRV_MedianNN"])
assert np.all(hrv_fast["HRV_MadNN"] < hrv_slow["HRV_MadNN"])
assert np.all(hrv_fast["HRV_MCVNN"] < hrv_slow["HRV_MCVNN"])
assert np.all(hrv_fast["HRV_pNN50"] == hrv_slow["HRV_pNN50"])
assert np.all(hrv_fast["HRV_pNN20"] < hrv_slow["HRV_pNN20"])
assert np.all(hrv_fast["HRV_TINN"] < hrv_slow["HRV_TINN"])
assert np.all(hrv_fast["HRV_HTI"] > hrv_slow["HRV_HTI"])
def test_hrv_frequency():
# Test frequency domain
ecg1 = nk.ecg_simulate(duration=60,
sampling_rate=2000,
heart_rate=70,
random_state=42)
_, peaks1 = nk.ecg_process(ecg1, sampling_rate=2000)
hrv1 = nk.hrv_frequency(peaks1, sampling_rate=2000)
ecg2 = nk.signal_resample(ecg1,
sampling_rate=2000,
desired_sampling_rate=500)
_, peaks2 = nk.ecg_process(ecg2, sampling_rate=500)
hrv2 = nk.hrv_frequency(peaks2, sampling_rate=500)
assert np.allclose(hrv1["HRV_HF"] - hrv2["HRV_HF"], 0, atol=1.5)
assert np.isnan(hrv1["HRV_LF"][0])
assert np.isnan(hrv2["HRV_LF"][0])
assert np.isnan(hrv1["HRV_VLF"][0])
assert np.isnan(hrv2["HRV_LF"][0])
# Test warning on too short duration
with pytest.warns(nk.misc.NeuroKitWarning,
match=r"The duration of recording is too short.*"):
ecg3 = nk.ecg_simulate(duration=10,
sampling_rate=2000,
heart_rate=70,
random_state=42)
_, peaks3 = nk.ecg_process(ecg3, sampling_rate=2000)
nk.hrv_frequency(peaks3, sampling_rate=2000, silent=False)
def test_ecg_hrv():
ecg_slow = nk.ecg_simulate(duration=60,
sampling_rate=1000,
heart_rate=70,
random_state=42)
ecg_fast = nk.ecg_simulate(duration=60,
sampling_rate=1000,
heart_rate=110,
random_state=42)
ecg_slow, _ = nk.ecg_process(ecg_slow, sampling_rate=1000)
ecg_fast, _ = nk.ecg_process(ecg_fast, sampling_rate=1000)
ecg_slow_hrv = nk.ecg_hrv(ecg_slow, sampling_rate=1000)
ecg_fast_hrv = nk.ecg_hrv(ecg_fast, sampling_rate=1000)
assert ecg_fast_hrv["HRV_RMSSD"][0] < ecg_slow_hrv["HRV_RMSSD"][0]
assert ecg_fast_hrv["HRV_MeanNN"][0] < ecg_slow_hrv["HRV_MeanNN"][0]
assert ecg_fast_hrv["HRV_SDNN"][0] < ecg_slow_hrv["HRV_SDNN"][0]
assert ecg_fast_hrv["HRV_CVNN"][0] < ecg_slow_hrv["HRV_CVNN"][0]
assert ecg_fast_hrv["HRV_CVSD"][0] < ecg_slow_hrv["HRV_CVSD"][0]
assert ecg_fast_hrv["HRV_MedianNN"][0] < ecg_slow_hrv["HRV_MedianNN"][0]
assert ecg_fast_hrv["HRV_MadNN"][0] < ecg_slow_hrv["HRV_MadNN"][0]
assert ecg_fast_hrv["HRV_MCVNN"][0] < ecg_slow_hrv["HRV_MCVNN"][0]
assert ecg_fast_hrv["HRV_pNN50"][0] == ecg_slow_hrv["HRV_pNN50"][0]
assert ecg_fast_hrv["HRV_pNN20"][0] < ecg_slow_hrv["HRV_pNN20"][0]
assert ecg_fast_hrv["HRV_TINN"][0] < ecg_slow_hrv["HRV_TINN"][0]
assert ecg_fast_hrv["HRV_HTI"][0] > ecg_slow_hrv["HRV_HTI"][0]
assert ecg_fast_hrv["HRV_ULF"][0] == ecg_slow_hrv["HRV_ULF"][0] == 0
assert all(elem in [
'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'
] for elem in np.array(ecg_fast_hrv.columns.values, dtype=str))
# Test frequency domain
ecg1 = nk.ecg_simulate(duration=60,
sampling_rate=2000,
heart_rate=70,
random_state=42)
hrv1 = nk.ecg_hrv(nk.ecg_process(ecg1, sampling_rate=2000)[0],
sampling_rate=2000)
ecg2 = nk.signal_resample(ecg1,
sampling_rate=2000,
desired_sampling_rate=500)
hrv2 = nk.ecg_hrv(nk.ecg_process(ecg2, sampling_rate=500)[0],
sampling_rate=500)
assert np.allclose(np.mean(hrv1[["HRV_HF", "HRV_LF", "HRV_VLF"]].iloc[0] -
hrv2[["HRV_HF", "HRV_LF", "HRV_VLF"]].iloc[0]),
0,
atol=1)
def test_ecg_plot():
ecg = nk.ecg_simulate(duration=60, heart_rate=70, noise=0.05)
ecg_summary, _ = nk.ecg_process(ecg, sampling_rate=1000, method="neurokit")
# Plot data over samples.
nk.ecg_plot(ecg_summary)
# This will identify the latest figure.
fig = plt.gcf()
assert len(fig.axes) == 2
titles = ["Raw and Cleaned Signal", "Heart Rate"]
for (ax, title) in zip(fig.get_axes(), titles):
assert ax.get_title() == title
assert fig.get_axes()[1].get_xlabel() == "Samples"
np.testing.assert_array_equal(fig.axes[0].get_xticks(),
fig.axes[1].get_xticks())
plt.close(fig)
# Plot data over seconds.
nk.ecg_plot(ecg_summary, sampling_rate=1000)
# This will identify the latest figure.
fig = plt.gcf()
assert len(fig.axes) == 3
titles = ["Raw and Cleaned Signal", "Heart Rate", "Individual Heart Beats"]
for (ax, title) in zip(fig.get_axes(), titles):
assert ax.get_title() == title
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)
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_hrv():
ecg = nk.ecg_simulate(duration=60,
sampling_rate=1000,
heart_rate=110,
random_state=42)
_, peaks = nk.ecg_process(ecg, sampling_rate=1000)
ecg_hrv = nk.hrv(peaks, sampling_rate=1000)
columns = [
'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_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', 'HRV_ApEn',
'HRV_SampEn'
]
assert all(elem in np.array(ecg_hrv.columns.values, dtype=object)
for elem in columns)
def test_ecg_process():
sampling_rate = 1000
noise = 0.05
ecg = nk.ecg_simulate(sampling_rate=sampling_rate, noise=noise)
signals, info = nk.ecg_process(ecg, sampling_rate=sampling_rate, method="neurokit")
def test_ecg_eventrelated():
ecg, info = nk.ecg_process(nk.ecg_simulate(duration=20))
epochs = nk.epochs_create(ecg,
events=[5000, 10000, 15000],
epochs_start=-0.1,
epochs_end=1.9)
ecg_eventrelated = nk.ecg_eventrelated(epochs)
# Test rate features
assert np.alltrue(
np.array(ecg_eventrelated["ECG_Rate_Min"]) < np.array(
ecg_eventrelated["ECG_Rate_Mean"]))
assert np.alltrue(
np.array(ecg_eventrelated["ECG_Rate_Mean"]) < np.array(
ecg_eventrelated["ECG_Rate_Max"]))
assert len(ecg_eventrelated["Label"]) == 3
assert len(ecg_eventrelated.columns) == 13
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", "Label"
] for elem in np.array(ecg_eventrelated.columns.values, dtype=str))
def test_ecg_eventrelated():
ecg, info = nk.ecg_process(nk.ecg_simulate(duration=20))
epochs = nk.epochs_create(ecg,
events=[5000, 10000, 15000],
epochs_start=-0.1,
epochs_end=1.9)
ecg_eventrelated = nk.ecg_eventrelated(epochs)
# Test rate features
assert np.alltrue(
np.array(ecg_eventrelated["ECG_Rate_Min"]) < np.array(
ecg_eventrelated["ECG_Rate_Mean"]))
assert np.alltrue(
np.array(ecg_eventrelated["ECG_Rate_Mean"]) < np.array(
ecg_eventrelated["ECG_Rate_Max"]))
assert len(ecg_eventrelated["Label"]) == 3
# Test warning on missing columns
with pytest.warns(nk.misc.NeuroKitWarning,
match=r".*does not have an `ECG_Phase_Artrial`.*"):
first_epoch_key = list(epochs.keys())[0]
first_epoch_copy = epochs[first_epoch_key].copy()
del first_epoch_copy["ECG_Phase_Atrial"]
nk.ecg_eventrelated({**epochs, first_epoch_key: first_epoch_copy})
with pytest.warns(nk.misc.NeuroKitWarning,
match=r".*does not have an.*`ECG_Phase_Ventricular`"):
first_epoch_key = list(epochs.keys())[0]
first_epoch_copy = epochs[first_epoch_key].copy()
del first_epoch_copy["ECG_Phase_Ventricular"]
nk.ecg_eventrelated({**epochs, first_epoch_key: first_epoch_copy})
with pytest.warns(nk.misc.NeuroKitWarning,
match=r".*does not have an `ECG_Quality`.*"):
first_epoch_key = list(epochs.keys())[0]
first_epoch_copy = epochs[first_epoch_key].copy()
del first_epoch_copy["ECG_Quality"]
nk.ecg_eventrelated({**epochs, first_epoch_key: first_epoch_copy})
with pytest.warns(nk.misc.NeuroKitWarning,
match=r".*does not have an `ECG_Rate`.*"):
first_epoch_key = list(epochs.keys())[0]
first_epoch_copy = epochs[first_epoch_key].copy()
del first_epoch_copy["ECG_Rate"]
nk.ecg_eventrelated({**epochs, first_epoch_key: first_epoch_copy})
# Test warning on long epochs (eventrelated_utils)
with pytest.warns(nk.misc.NeuroKitWarning,
match=r".*duration of your epochs seems.*"):
first_epoch_key = list(epochs.keys())[0]
first_epoch_copy = epochs[first_epoch_key].copy()
first_epoch_copy.index = range(len(first_epoch_copy))
nk.ecg_eventrelated({**epochs, first_epoch_key: first_epoch_copy})
def segment(yClean):
ECG_signal, info = nk.ecg_process(yClean, sampling_rate=1000)
# Visualise the processing
# plt.savefig('./images/signal_varios.png')
fig = Figure()
axis = fig.add_subplot(1, 1, 1)
nk.ecg_plot(ECG_signal, sampling_rate=1000)
return nk.ecg_plot(ECG_signal, sampling_rate=1000)
def test_ecg_hrv():
ecg_slow = nk.ecg_simulate(duration=60,
sampling_rate=1000,
heart_rate=70,
random_state=42)
ecg_fast = nk.ecg_simulate(duration=60,
sampling_rate=1000,
heart_rate=110,
random_state=42)
ecg_slow, _ = nk.ecg_process(ecg_slow)
ecg_fast, _ = nk.ecg_process(ecg_fast)
ecg_slow_hrv = nk.ecg_hrv(ecg_slow)
ecg_fast_hrv = nk.ecg_hrv(ecg_fast)
assert ecg_fast_hrv["HRV_RMSSD"][0] < ecg_slow_hrv["HRV_RMSSD"][0]
assert ecg_fast_hrv["HRV_MeanNN"][0] < ecg_slow_hrv["HRV_MeanNN"][0]
assert ecg_fast_hrv["HRV_SDNN"][0] < ecg_slow_hrv["HRV_SDNN"][0]
assert ecg_fast_hrv["HRV_CVNN"][0] < ecg_slow_hrv["HRV_CVNN"][0]
assert ecg_fast_hrv["HRV_CVSD"][0] < ecg_slow_hrv["HRV_CVSD"][0]
assert ecg_fast_hrv["HRV_MedianNN"][0] < ecg_slow_hrv["HRV_MedianNN"][0]
assert ecg_fast_hrv["HRV_MadNN"][0] < ecg_slow_hrv["HRV_MadNN"][0]
assert ecg_fast_hrv["HRV_MCVNN"][0] < ecg_slow_hrv["HRV_MCVNN"][0]
assert ecg_fast_hrv["HRV_pNN50"][0] == ecg_slow_hrv["HRV_pNN50"][0]
assert ecg_fast_hrv["HRV_pNN20"][0] < ecg_slow_hrv["HRV_pNN20"][0]
assert ecg_fast_hrv["HRV_TINN"][0] < ecg_slow_hrv["HRV_TINN"][0]
# assert ecg_fast_hrv["HRV_HTI"][0] > ecg_slow_hrv["HRV_HTI"][0]
# assert ecg_fast_hrv["HRV_ULF"][0] == ecg_slow_hrv["HRV_ULF"][0] == 0
# assert ecg_fast_hrv["HRV_VLF"][0] < ecg_slow_hrv["HRV_VLF"][0]
# assert ecg_fast_hrv["HRV_LF"][0] < ecg_slow_hrv["HRV_LF"][0]
# assert ecg_fast_hrv["HRV_HF"][0] < ecg_slow_hrv["HRV_HF"][0]
# assert ecg_fast_hrv["HRV_VHF"][0] > ecg_slow_hrv["HRV_VHF"][0]
assert all(elem in [
'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'
] for elem in np.array(ecg_fast_hrv.columns.values, dtype=str))
def test_hrv_frequency():
# Test frequency domain
ecg1 = nk.ecg_simulate(duration=60,
sampling_rate=2000,
heart_rate=70,
random_state=42)
_, peaks1 = nk.ecg_process(ecg1, sampling_rate=2000)
hrv1 = nk.hrv_frequency(peaks1, sampling_rate=2000)
ecg2 = nk.signal_resample(ecg1,
sampling_rate=2000,
desired_sampling_rate=500)
_, peaks2 = nk.ecg_process(ecg2, sampling_rate=500)
hrv2 = nk.hrv_frequency(peaks2, sampling_rate=500)
assert np.allclose(hrv1["HRV_HF"] - hrv2["HRV_HF"], 0, atol=1.5)
assert np.isnan(hrv1["HRV_LF"][0])
assert np.isnan(hrv2["HRV_LF"][0])
assert np.isnan(hrv1["HRV_VLF"][0])
assert np.isnan(hrv2["HRV_LF"][0])
def test_ecg_eventrelated():
ecg, info = nk.ecg_process(nk.ecg_simulate(duration=20))
epochs = nk.epochs_create(ecg, events=[5000, 10000, 15000], epochs_start=-0.1, epochs_end=1.9)
ecg_eventrelated = nk.ecg_eventrelated(epochs)
# Test rate features
assert np.alltrue(np.array(ecg_eventrelated["ECG_Rate_Min"]) < np.array(ecg_eventrelated["ECG_Rate_Mean"]))
assert np.alltrue(np.array(ecg_eventrelated["ECG_Rate_Mean"]) < np.array(ecg_eventrelated["ECG_Rate_Max"]))
assert len(ecg_eventrelated["Label"]) == 3
def test_ecg_process():
sampling_rate = 1000
noise = 0.05
ecg = nk.ecg_simulate(sampling_rate=sampling_rate, noise=noise)
signals, info = nk.ecg_process(ecg,
sampling_rate=sampling_rate,
method="neurokit")
# Only check array dimensions and column names since functions called by
# ecg_process have already been unit tested
assert all(elem in ["ECG_Raw", "ECG_Clean", "ECG_R_Peaks", "ECG_Rate"]
for elem in np.array(signals.columns.values, dtype=str))
def test_ecg_process():
sampling_rate = 1000
noise = 0.05
ecg = nk.ecg_simulate(sampling_rate=sampling_rate, noise=noise)
signals, info = nk.ecg_process(ecg, sampling_rate=sampling_rate,
method="neurokit")
# Only check array dimensions and column names since functions called by
# ecg_process have already been unit tested
assert all(elem in ["ECG_Raw", "ECG_Clean", "ECG_R_Peaks", "ECG_Rate",
'ECG_Quality', "ECG_P_Peaks",
"ECG_Q_Peaks", "ECG_S_Peaks",
"ECG_T_Peaks", "ECG_P_Onsets", "ECG_T_Offsets",
"ECG_Atrial_Phase", "ECG_Ventricular_Phase",
"ECG_Atrial_PhaseCompletion",
"ECG_Ventricular_PhaseCompletion"]
for elem in np.array(signals.columns.values, dtype=str))
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_hrv():
ecg = nk.ecg_simulate(duration=60,
sampling_rate=1000,
heart_rate=110,
random_state=42)
_, peaks = nk.ecg_process(ecg, sampling_rate=1000)
ecg_hrv = nk.hrv(peaks, sampling_rate=1000)
assert all(elem in [
'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'
] for elem in np.array(ecg_hrv.columns.values, dtype=str))
def process_row(index, row, verbose=False):
try:
signals, _ = nk.ecg_process(row, sampling_rate=300)
peak_types = [
"ECG_P_Peaks", "ECG_Q_Peaks", "ECG_R_Peaks", "ECG_S_Peaks",
"ECG_T_Peaks"
]
peaks = [
list(signals.index[signals[peak_type] == 1])
for peak_type in peak_types
]
ecg_clean = signals[['ECG_Clean']]
except Exception as inst:
# NeuroKit2 Problems: sometimes it fails miserably during nk.ecg_process() for weird reasons that by my
# investigation shouldn't be occuring.
# TODO: FIND A BETTER LIBRARY (for now just replace with zeros)
if verbose:
print(index, " failed with error: ", inst)
peaks = None
ecg_clean = None
return extract_features_peaks(index, peaks, ecg_clean, verbose)
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_ecg_process_func(signal,
start,
n_samples,
fs,
plot_builtin=False,
plot_events=True):
"""Runs neurokit.ecg_process() on specified section of data and plots builtin plot or plot that
shows P, R, and T waves, atrial/ventricular phases, and peaks.
:param signal: array of data
:param start: start index in signal
:param n_samples: how many samples to process
:param fs: sample rate, Hz
:param plot_builtin: Boolean; runs neurokit.ecg_plot()
:param plot_events: boolean: runs custom plot
:return: data objects generated in neurokit.ecg_process()
"""
s, i = nk.ecg_process(signal[start:start + n_samples], fs)
if plot_events:
fig, axes = plt.subplots(1, figsize=(10, 6))
axes.plot(np.arange(0, s.shape[0]) / fs,
s["ECG_Clean"],
label="Filtered",
color='black')
axes.plot(s.loc[s["ECG_R_Peaks"] == 1].index / fs,
s.loc[s["ECG_R_Peaks"] == 1]["ECG_Clean"],
marker="o",
linestyle="",
color='grey',
label="R Peak")
axes.plot(s.loc[s["ECG_T_Peaks"] == 1].index / fs,
s.loc[s["ECG_T_Peaks"] == 1]["ECG_Clean"],
marker="x",
linestyle="",
color='red',
label="T Peak")
axes.plot(s.loc[s["ECG_P_Peaks"] == 1].index / fs,
s.loc[s["ECG_P_Peaks"] == 1]["ECG_Clean"],
marker="x",
linestyle="",
color='green',
label="P Peak")
axes.legend(loc='lower left')
axes2 = axes.twinx()
axes2.set_yticks([])
axes2.set_ylim(0, 1)
axes2.fill_between(x=np.arange(0, s.shape[0]) / fs,
y1=.5,
y2=s["ECG_Phase_Atrial"].replace(to_replace=0,
value=.5),
color='green',
alpha=.25,
label="Atrial phase")
axes2.fill_between(x=np.arange(0, s.shape[0]) / fs,
y1=.5,
y2=s["ECG_Phase_Ventricular"].replace(to_replace=0,
value=.5),
color='purple',
alpha=.25,
label="Ventr. phase")
p_start = s.loc[s["ECG_P_Onsets"] == 1]
p_end = s.loc[s["ECG_P_Offsets"] == 1]
t_start = s.loc[s["ECG_T_Onsets"] == 1]
t_end = s.loc[s["ECG_T_Offsets"] == 1]
r_start = s.loc[s["ECG_R_Onsets"] == 1]
r_end = s.loc[s["ECG_R_Offsets"] == 1]
for i in range(p_start.shape[0]):
if i == range(p_start.shape[0])[-1]:
axes2.fill_between(
x=[p_start.index[i] / fs, p_end.index[i] / fs],
y1=0,
y2=.5,
color='dodgerblue',
alpha=.25,
label="P wave")
else:
axes2.fill_between(
x=[p_start.index[i] / fs, p_end.index[i] / fs],
y1=0,
y2=.5,
color='dodgerblue',
alpha=.25)
for i in range(t_start.shape[0]):
if i == range(t_start.shape[0])[-1]:
axes2.fill_between(
x=[t_start.index[i] / fs, t_end.index[i] / fs],
y1=0,
y2=.5,
color='red',
alpha=.25,
label="T wave")
else:
axes2.fill_between(
x=[t_start.index[i] / fs, t_end.index[i] / fs],
y1=0,
y2=.5,
color='red',
alpha=.25)
for i in range(r_start.shape[0]):
if i == range(r_start.shape[0])[-1]:
axes2.fill_between(
x=[r_start.index[i] / fs, r_end.index[i] / fs],
y1=0,
y2=.5,
color='grey',
alpha=.25,
label="R wave")
else:
axes2.fill_between(
x=[r_start.index[i] / fs, r_end.index[i] / fs],
y1=0,
y2=.5,
color='grey',
alpha=.25)
axes2.legend(loc='lower right')
axes.set_xlabel("Seconds")
if plot_builtin:
nk.ecg_plot(s, fs)
return s, i
def featurize_ecg(self, recording, sample_freq):
"""
Automatically derives features from ECG-files (only .dat files for now)
Args:
R-peaks
P-peaks
T-peaks
features (numpy array of str): an array of ECG-filenames in directory
labels (numpy array): an array of labels/diagnosis
directory (str): path to the features
demographical_data (DataFrame): A DataFrame containing feature name, age and gender
Returns:
features_out (DataFrame): A DataFrame with features for all ECG-records
"""
def interval_calc_simple(first_peak, second_peak, sample_freq):
try:
mean_interval = round((second_peak - first_peak).mean(), 5)
except:
mean_interval = float("NaN")
try:
std_interval = round((second_peak - first_peak).std(), 5)
except:
std_interval = float("NaN")
return mean_interval, std_interval
feature_list = []
feature_name = []
try:
temp_data = nk.ecg_process(recording, sample_freq)[0]
r_peaks = np.where(temp_data['ECG_R_Peaks'] == 1)[0]
p_peaks = np.where(temp_data['ECG_P_Peaks'] == 1)[0]
q_peaks = np.where(temp_data['ECG_Q_Peaks'] == 1)[0]
s_peaks = np.where(temp_data['ECG_S_Peaks'] == 1)[0]
t_peaks = np.where(temp_data['ECG_T_Peaks'] == 1)[0]
p_onset = np.where(temp_data['ECG_P_Onsets'] == 1)[0]
t_offset = np.where(temp_data['ECG_T_Offsets'] == 1)[0]
analysis = True
except:
analysis = False
r_peaks = np.array([1, 2])
p_peaks = np.array([1, 2])
q_peaks = np.array([1, 2])
s_peaks = np.array([1, 2])
t_peaks = np.array([1, 2])
if self.rpeak_int == True:
feature_name.append("mean_rr_interval")
feature_name.append("sd_rr_interval")
if analysis == False:
feature_list.append(float("nan"))
feature_list.append(float("nan"))
elif analysis == True:
feature_list.append((np.diff(r_peaks) / sample_freq).mean())
feature_list.append((np.diff(r_peaks) / sample_freq).std())
if self.rpeak_amp == True:
feature_name.append("mean_r_peak")
feature_name.append("sd_r_peak")
if analysis == False:
feature_list.append(float("nan"))
feature_list.append(float("nan"))
elif analysis == True:
# Dont use cleaned signal
feature_list.append(recording[r_peaks].mean())
feature_list.append(recording[r_peaks].std())
if self.ppeak_int == True:
feature_name.append("mean_pp_interval")
feature_name.append("sd_pp_interval")
if analysis == False:
feature_list.append(float("nan"))
feature_list.append(float("nan"))
elif analysis == True:
feature_list.append((np.diff(p_peaks) / sample_freq).mean())
feature_list.append((np.diff(p_peaks) / sample_freq).std())
if self.ppeak_amp == True:
feature_name.append("mean_p_peak")
feature_name.append("sd_p_peak")
if analysis == False:
feature_list.append(float("nan"))
feature_list.append(float("nan"))
elif analysis == True:
feature_list.append(temp_data['ECG_Clean'][p_peaks].mean())
feature_list.append(temp_data['ECG_Clean'][p_peaks].std())
if self.tpeak_int == True:
feature_name.append("mean_tt_interval")
feature_name.append("sd_tt_interval")
if analysis == False:
feature_list.append(float("nan"))
feature_list.append(float("nan"))
elif analysis == True:
feature_list.append((np.diff(t_peaks) / sample_freq).mean())
feature_list.append((np.diff(t_peaks) / sample_freq).std())
if self.tpeak_amp == True:
feature_name.append("mean_t_peak")
feature_name.append("sd_t_peak")
if analysis == False:
feature_list.append(float("nan"))
feature_list.append(float("nan"))
elif analysis == True:
feature_list.append(temp_data['ECG_Clean'][t_peaks].mean())
feature_list.append(temp_data['ECG_Clean'][t_peaks].std())
if self.qpeak_int == True:
feature_name.append("mean_qq_interval")
feature_name.append("sd_qq_interval")
if analysis == False:
feature_list.append(float("nan"))
feature_list.append(float("nan"))
elif analysis == True:
feature_list.append((np.diff(q_peaks) / sample_freq).mean())
feature_list.append((np.diff(q_peaks) / sample_freq).std())
if self.qpeak_amp == True:
feature_name.append("mean_q_peak")
feature_name.append("sd_q_peak")
if analysis == False:
feature_list.append(float("nan"))
feature_list.append(float("nan"))
elif analysis == True:
feature_list.append(temp_data['ECG_Clean'][q_peaks].mean())
feature_list.append(temp_data['ECG_Clean'][q_peaks].std())
if self.speak_int == True:
feature_name.append("mean_q_peak")
feature_name.append("sd_q_peak")
if analysis == False:
feature_list.append(float("nan"))
feature_list.append(float("nan"))
elif analysis == True:
feature_list.append((np.diff(s_peaks) / sample_freq).mean())
feature_list.append((np.diff(s_peaks) / sample_freq).std())
if self.speak_amp == True:
feature_name.append("mean_s_peak")
feature_name.append("sd_s_peak")
if analysis == False:
feature_list.append(float("nan"))
feature_list.append(float("nan"))
elif analysis == True:
feature_list.append(temp_data['ECG_Clean'][s_peaks].mean())
feature_list.append(temp_data['ECG_Clean'][s_peaks].std())
if self.qrs_duration == True:
feature_name.append("qrs_mean")
feature_name.append("qrs_std")
if analysis == False:
feature_list.append(float("nan"))
feature_list.append(float("nan"))
elif analysis == True:
qrs_mean, qrs_std = interval_calc_simple(
q_peaks, s_peaks, sample_freq)
feature_list.append(qrs_mean)
feature_list.append(qrs_std)
if self.qt_duration == True:
feature_name.append("qt_mean")
feature_name.append("qt_std")
if analysis == False:
feature_list.append(float("nan"))
feature_list.append(float("nan"))
elif analysis == True:
qt_mean, qt_std = interval_calc_simple(q_peaks, t_peaks,
sample_freq)
feature_list.append(qt_mean)
feature_list.append(qt_std)
if self.pr_duration == True:
feature_name.append("pr_mean")
feature_name.append("pr_std")
if analysis == False:
feature_list.append(float("nan"))
feature_list.append(float("nan"))
elif analysis == True:
pr_mean, pr_std = interval_calc_simple(p_peaks, r_peaks,
sample_freq)
feature_list.append(pr_mean)
feature_list.append(pr_std)
feature_list = np.asarray(feature_list)
feature_name = np.asarray(feature_name)
return feature_list, feature_name, [
p_peaks, q_peaks, r_peaks, s_peaks, t_peaks
]
def process_epochs_neurokit(signal, window_len=300, jump_len=300):
t = datetime.now()
indexes = np.arange(0, len(signal), int(jump_len * data.sample_rate))
print(
f"\nRunning NeuroKit analysis in {window_len}-second windows with jump interval of {jump_len} seconds"
f"({len(indexes)} iterations)...")
# Within-epoch processing using NeuroKit to match Cardioscope output
df_nk = pd.DataFrame([[], [], [], [], [], [], [], [], [], [], [], [], [],
[], [], []]).transpose()
df_nk.columns = [
"Timestamp", "Index", "Quality", "HR", "meanRR", "sdRR", "meanNN",
"SDNN", "pNN20", 'pNN50', "VLF", "LF", "HF", "LF/HF", "LFn", "HFn"
]
print("\nProcessing data in epochs with NeuroKit2...")
for start in indexes:
print(f"{round(100*start/len(signal), 1)}%")
try:
s, i = nk.ecg_process(signal[start:start +
int(data.sample_rate * window_len)],
sampling_rate=data.sample_rate)
s = s.loc[s["ECG_R_Peaks"] == 1]
inds = [i for i in s.index]
hrv = nk.hrv_time(peaks=inds,
sampling_rate=data.sample_rate,
show=False)
freq = nk.hrv_frequency(peaks=inds,
sampling_rate=data.sample_rate,
show=False)
rr_ints = [(d2 - d1) / data.sample_rate
for d1, d2 in zip(inds[:], inds[1:])]
mean_rr = 1000 * np.mean(rr_ints)
sd_rr = 1000 * np.std(rr_ints)
out = [
data.timestamps[start], start, 100 * s["ECG_Quality"].mean(),
s["ECG_Rate"].mean().__round__(3), mean_rr, sd_rr,
hrv["HRV_MeanNN"].iloc[0], hrv["HRV_SDNN"].iloc[0],
hrv["HRV_pNN20"].iloc[0], hrv["HRV_pNN50"].iloc[0],
freq["HRV_VLF"].iloc[0], freq["HRV_LF"].iloc[0],
freq["HRV_HF"].iloc[0], freq["HRV_LFHF"].iloc[0],
freq["HRV_LFn"].iloc[0], freq["HRV_HFn"].iloc[0]
]
df_out = pd.DataFrame(out).transpose()
df_out.columns = df_nk.columns
df_nk = df_nk.append(df_out, ignore_index=True)
except (ValueError, IndexError):
out = [
data.timestamps[start], start, None, None, None, None, None,
None, None, None, None, None, None, None, None
]
df_out = pd.DataFrame(out).transpose()
df_out.columns = df_nk.columns
df_nk = df_nk.append(df_out, ignore_index=True)
t1 = datetime.now()
td = (t1 - t).total_seconds()
print(f"100% ({round(td, 1)} seconds)")
df_nk["Timestamp"] = pd.date_range(start=bf["Timestamp"].iloc[0],
freq=f"{jump_len}S",
periods=df_nk.shape[0])
return df_nk
plot = nk.eda_plot(signals, sampling_rate=None)
plot.set_size_inches(10, 6, forward=True)
plot.savefig("README_eda.png", dpi=300, h_pad=3)
# =============================================================================
# Cardiac activity (ECG) processing
# =============================================================================
# Generate 15 seconds of ECG signal (recorded at 250 samples / second)
ecg = nk.ecg_simulate(duration=15,
sampling_rate=250,
heart_rate=70,
random_state=333)
# Process it
signals, info = nk.ecg_process(ecg, sampling_rate=250)
# Visualise the processing
nk.ecg_plot(signals, sampling_rate=250)
# Save it
plot = nk.ecg_plot(signals, sampling_rate=250)
plot.set_size_inches(10, 6, forward=True)
plot.savefig("README_ecg.png", dpi=300, h_pad=3)
# =============================================================================
# Respiration (RSP) processing
# =============================================================================
# Generate one minute of RSP signal (recorded at 250 samples / second)
rsp = nk.rsp_simulate(duration=60, sampling_rate=250, respiratory_rate=15)
def analyzeECG(ecg, sampling_rate, method = "dwt"):
#Funkcja zwraca parametry analizy, które mogą być wykorzystane do wyświetlania oraz do dalszej analizy.
#Zwraca puls, średnią HRV, HRVSDNN, HRVRMSSD, informacje związane z załamkami (długość, czas, amplituda)
a, peaks = nk.ecg_process(ecg[1], sampling_rate = sampling_rate)
info = nk.ecg_analyze(a, sampling_rate = sampling_rate)
ECG_Rate_Mean = info["ECG_Rate_Mean"][0]
HRV_RMSSD = info["HRV_RMSSD"][0]
HRV_MeanNN = info["HRV_MeanNN"][0]
HRV_SDNN = info["HRV_SDNN"][0]
_,rpeaksnk = nk.ecg_peaks(ecg[1], sampling_rate = sampling_rate)
R_peaks = [[],[]]
for i in rpeaksnk["ECG_R_Peaks"]:
R_peaks[0].append(ecg[0][i])
R_peaks[1].append(ecg[1][i])
# Delineate the ECG signal
_, waves_peak = nk.ecg_delineate(ecg[1], rpeaksnk, sampling_rate = sampling_rate, show = False,
show_type = "peaks")
if method == "cwt":
_, waves_other = nk.ecg_delineate(ecg[1], rpeaksnk, sampling_rate = sampling_rate,
method="cwt", show=False, show_type='all')
if method == "dwt":
_, waves_other = nk.ecg_delineate(ecg[1], rpeaksnk, sampling_rate = sampling_rate,
method="dwt", show=False, show_type='all')
#Wyznaczanie załamków P, Q, S, T
P_peaks = [[],[]]
Q_peaks = [[],[]]
S_peaks = [[],[]]
T_peaks = [[],[]]
for name in waves_peak:
for i in waves_peak[str(name)]:
if math.isnan(i):
continue
if str(name) == "ECG_P_Peaks":
P_peaks[0].append(ecg[0][i])
P_peaks[1].append(ecg[1][i])
if str(name) == "ECG_Q_Peaks":
Q_peaks[0].append(ecg[0][i])
Q_peaks[1].append(ecg[1][i])
if str(name) == "ECG_S_Peaks":
S_peaks[0].append(ecg[0][i])
S_peaks[1].append(ecg[1][i])
if str(name) == "ECG_T_Peaks":
T_peaks[0].append(ecg[0][i])
T_peaks[1].append(ecg[1][i])
#Wyznaczanie początków i końców załamków P, Q, S, T
P_onsets = [[],[]]
P_offsets = [[],[]]
R_onsets = [[],[]]
R_offsets = [[],[]]
T_onsets = [[],[]]
T_offsets = [[],[]]
for name in waves_other:
for i in waves_other[str(name)]:
if math.isnan(i):
continue
if str(name) == "ECG_P_Onsets":
P_onsets[0].append(ecg[0][i])
P_onsets[1].append(ecg[1][i])
if str(name) == "ECG_P_Offsets":
P_offsets[0].append(ecg[0][i])
P_offsets[1].append(ecg[1][i])
if str(name) == "ECG_R_Onsets":
R_onsets[0].append(ecg[0][i])
R_onsets[1].append(ecg[1][i])
if str(name) == "ECG_R_Offsets":
R_offsets[0].append(ecg[0][i])
R_offsets[1].append(ecg[1][i])
if str(name) == "ECG_T_Onsets":
T_onsets[0].append(ecg[0][i])
T_onsets[1].append(ecg[1][i])
if str(name) == "ECG_T_Offsets":
T_offsets[0].append(ecg[0][i])
T_offsets[1].append(ecg[1][i])
#Czasy załamków
P_Time = calculateTime(P_offsets[0], P_onsets[0])
QRS_Time = calculateTime(R_offsets[0], R_onsets[0])
T_Time = calculateTime(T_offsets[0], T_onsets[0])
#Amplitudy załamków
P_Amplitude = np.mean(P_peaks[1])
Q_Amplitude = np.mean(Q_peaks[1])
R_Amplitude = np.mean(R_peaks[1])
S_Amplitude = np.mean(S_peaks[1])
T_Amplitude = np.mean(T_peaks[1])
#Odstępy
PQ_Space = calculateTime(R_onsets[0], P_onsets[0])
QT_Space = calculateTime(T_offsets[0], R_onsets[0])
#Odcinki
PQ_Segment = calculateTime(R_onsets[0], P_offsets[0])
ST_Segment = calculateTime(T_onsets[0], R_offsets[0])
#Słowniki z pozyskanymi informacjami
data = {}
info = {}
data["P_peaks"] = P_peaks
data["Q_peaks"] = Q_peaks
data["R_peaks"] = R_peaks
data["S_peaks"] = S_peaks
data["T_peaks"] = T_peaks
data["P_onsets"] = P_onsets
data["P_offsets"] = P_offsets
data["R_onsets"] = R_onsets
data["R_offsets"] = R_offsets
data["T_onsets"] = T_onsets
data["T_offsets"] = T_offsets
info["ECG_Rate_Mean"] = round(ECG_Rate_Mean, 4)
info["HRV_MeanNN"] = round(HRV_MeanNN, 4)
info["HRV_RMSSD"] = round(HRV_RMSSD, 4)
info["HRV_SDNN"] = round(HRV_SDNN, 4)
info["P_Time"] = round(P_Time, 4)
info["QRS_Time"] = round(QRS_Time, 4)
info["T_Time"] = round(T_Time, 4)
info["P_Amplitude"] = round(P_Amplitude, 4)
info["Q_Amplitude"] = round(Q_Amplitude, 4)
info["R_Amplitude"] = round(R_Amplitude, 4)
info["S_Amplitude"] = round(S_Amplitude, 4)
info["T_Amplitude"] = round(T_Amplitude, 4)
info["PQ_Space"] = round(PQ_Space, 4)
info["QT_Space"] = round(QT_Space, 4)
info["PQ_Segment"] = round(PQ_Segment, 4)
info["ST_Segment"] = round(ST_Segment, 4)
return data, info
total = 0
path = u'DREAMER.mat'
data = sio.loadmat(path)
print("ECG signals are being feature extracted...")
ECG = {}
for k in range(0, 23):
for j in range(0, 18):
basl_l = data['DREAMER'][0, 0]['Data'][0, k]['ECG'][
0, 0]['baseline'][0, 0][j, 0][:, 0]
stim_l = data['DREAMER'][0, 0]['Data'][0, k]['ECG'][
0, 0]['stimuli'][0, 0][j, 0][:, 0]
basl_r = data['DREAMER'][0, 0]['Data'][0, k]['ECG'][
0, 0]['baseline'][0, 0][j, 0][:, 1]
stim_r = data['DREAMER'][0, 0]['Data'][0, k]['ECG'][
0, 0]['stimuli'][0, 0][j, 0][:, 1]
ecg_signals_b_l, info_b_l = nk.ecg_process(basl_l,
sampling_rate=256)
ecg_signals_s_l, info_s_l = nk.ecg_process(stim_l,
sampling_rate=256)
ecg_signals_b_r, info_b_r = nk.ecg_process(basl_r,
sampling_rate=256)
ecg_signals_s_r, info_s_r = nk.ecg_process(stim_r,
sampling_rate=256)
# processed_ecg_b_l = nk.ecg_intervalrelated(ecg_signals_b_l)
# processed_ecg_s_l = nk.ecg_intervalrelated(ecg_signals_s_l)
# processed_ecg_b_r = nk.ecg_intervalrelated(ecg_signals_b_r)
# processed_ecg_s_r = nk.ecg_intervalrelated(ecg_signals_s_r)
processed_ecg_l = nk.ecg_intervalrelated(
ecg_signals_s_l) / nk.ecg_intervalrelated(ecg_signals_b_l)
processed_ecg_r = nk.ecg_intervalrelated(
ecg_signals_s_r) / nk.ecg_intervalrelated(ecg_signals_b_r)
processed_ecg = (processed_ecg_l + processed_ecg_r) / 2
def process_hr(data):
signals, info = nk.ecg_process(data, sampling_rate=100)
return np.mean(signals['ECG_Rate'])
