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'])