def extract_features(data, sampling_rate):
detector = Detectors(sampling_rate)
hrv_class = HRV(sampling_rate)
# Borrar si todo va bien
# np.array_split(data, sampling_rate)
# PROCESAR POR TROZOS
# FOR splitted data
# Unir horizontalmente ecg y eda
# unir verticalmente cada iteracion
splitted = split_in_seconds(data, sampling_rate, 30)
seccion = None
names = None
for idx, m in enumerate(splitted):
print(f'Procesando split {idx} con longitud {len(m)}')
try:
ecg, names_ecg = ecg_processing(m[:, 1], detector, hrv_class)
eda, names_eda = eda_processing(m[:, 0])
full_iteration = np.hstack((eda, ecg))
if seccion is None:
seccion = np.empty((0, len(full_iteration)))
names = names_eda + names_ecg + ["stress_lvl"]
seccion = np.vstack((seccion, full_iteration))
except Exception:
print("Error en un dato. Continuando...")
continue
return seccion, names
for i in range(total_subjects):
#for i in range(2):
print(i)
sitting_class = Ecg(data_path, i, 'sitting')
sitting_class.filter_data()
maths_class = Ecg(data_path, i, 'maths')
maths_class.filter_data()
detectors = Detectors(sitting_class.fs)
if sitting_class.anno_cs_exists and maths_class.anno_cs_exists and (i !=
11):
subject.append(i)
hrv_class = HRV(sitting_class.fs)
if "e" in sys.argv[1]:
ecg_channel_sitting = sitting_class.einthoven_II
ecg_channel_maths = maths_class.einthoven_II
elif "v" in sys.argv[1]:
ecg_channel_sitting = sitting_class.cs_V2_V1
ecg_channel_maths = maths_class.cs_V2_V1
else:
print(
"Bad argument. Specify 'e' for Einthoven or 'v' for the Chest strap."
)
exit(1)
r_peaks = detectors.swt_detector(ecg_channel_sitting)
sitting_rr_sd.append(hrv_class.RMSSD(r_peaks, True))
total_subjects = 25
subject = []
for i in range(total_subjects):
#for i in range(2):
print(i)
sitting_class = GUDb(i, 'sitting')
sitting_class.filter_data()
maths_class = GUDb(i, 'maths')
maths_class.filter_data()
if sitting_class.anno_cs_exists and maths_class.anno_cs_exists:
subject.append(i)
hrv_class = HRV(sitting_class.fs)
maths_true_rr = maths_class.anno_cs
maths_true_hf.append(hrv_class.fAnalysis(maths_true_rr))
sitting_true_rr = sitting_class.anno_cs
sitting_true_hf.append(hrv_class.fAnalysis(sitting_true_rr))
subject = np.array(subject)
width = 0.3
fig, ax = plt.subplots()
rects1 = ax.bar(subject + (0 * width), sitting_true_hf, width)
rects2 = ax.bar(subject + (1 * width), maths_true_hf, width)
ax.set_ylabel('LF/HF ratio')
subject = []
do_normalise = True
for i in range(total_subjects):
#for i in range(2):
print(i)
sitting_class = GUDb(i, 'sitting')
sitting_class.filter_data()
maths_class = GUDb(i, 'maths')
maths_class.filter_data()
if sitting_class.anno_cs_exists and maths_class.anno_cs_exists:
subject.append(i)
hrv_class = HRV(sitting_class.fs)
maths_true_rr = maths_class.anno_cs
maths_true.append(
hrv_class.RMSSD(maths_true_rr, normalise=do_normalise))
sitting_true_rr = sitting_class.anno_cs
sitting_true.append(
hrv_class.RMSSD(sitting_true_rr, normalise=do_normalise))
subject = np.array(subject)
width = 0.4
fig, ax = plt.subplots()
rects1 = ax.bar(subject + (0 * width), sitting_true, width)
rects2 = ax.bar(subject + (1 * width), maths_true, width)
def ECGfeatures(self, df, sampling_rate=500):
drivers = df['Driver'].value_counts()
df.reset_index(inplace=True)
# Filtering ECG to remove noise
for dr in drivers.index:
after = ecg.ecg(signal=df.loc[df['Driver'] == dr, 'ECG'],
sampling_rate=sampling_rate,
show=False)
df.loc[df['Driver'] == dr, 'ECG'] = after[1]
#Calculating R-R Peaks
detectors = Detectors(sampling_rate)
r_peaks = detectors.engzee_detector(df['ECG'])
# Calculating R-R Interval
df['RMSSD'] = [0 for _ in range(len(df))]
rp = pd.Series(r_peaks)
hrv_obj = HRV(sampling_rate)
for dr in drivers.index:
start = df.loc[df['Driver'] == dr].index[0]
end = df.loc[df['Driver'] == dr].index[-1]
RMSSD = hrv_obj.RMSSD(rp[(rp > start) & (rp < end)],
normalise=False)
df.loc[df['Driver'] == dr, 'RMSSD'] = RMSSD
print('Finished extracting RMSSD successfully')
drivers = df['Driver'].value_counts().keys()
# Calculating other ECG features
df['meanNN'] = [0 for _ in range(len(df))]
df['sdNN'] = [0 for _ in range(len(df))]
df['cvNN'] = [0 for _ in range(len(df))]
df['CVSD'] = [0 for _ in range(len(df))]
df['medianNN'] = [0 for _ in range(len(df))]
df['madNN'] = [0 for _ in range(len(df))]
df['mcvNN'] = [0 for _ in range(len(df))]
df['pNN20'] = [0 for _ in range(len(df))]
df['pNN50'] = [0 for _ in range(len(df))]
for dr in drivers:
start = df.loc[df['Driver'] == dr, :].index[0]
end = df.loc[df['Driver'] == dr, :].index[-1]
crop = rp[(rp > start) & (rp < end)].diff()
rmssd = df.loc[start, 'RMSSD']
meanNN = crop.mean()
df.loc[df['Driver'] == dr, 'meanNN'] = meanNN
std = crop.std()
df.loc[df['Driver'] == dr, 'sdNN'] = std
cvNN = std / meanNN
df.loc[df['Driver'] == dr, 'cvNN'] = cvNN
cvsd = rmssd / meanNN
df.loc[df['Driver'] == dr, 'CVSD'] = cvsd
medianNN = crop.median()
df.loc[df['Driver'] == dr, 'medianNN'] = medianNN
madNN = crop.mad()
df.loc[df['Driver'] == dr, 'madNN'] = madNN
mcvNN = madNN / medianNN
df.loc[df['Driver'] == dr, 'mcvNN'] = mcvNN
pNN20 = hrv_obj.pNN20(crop)
df.loc[df['Driver'] == dr, 'pNN20'] = pNN20
pNN50 = hrv_obj.pNN50(crop)
df.loc[df['Driver'] == dr, 'pNN50'] = pNN50
print(
'Finished extracting meanNN, sdNN, cvNN, CVSD, medianNN, madNN, mcvNN, pNN20, pNN50 successfully'
)
self.df = df
return df
from ecgdetectors import Detectors
import scipy.stats as stats
import sys
from ecg_gudb_database import GUDb
# for plotting max hflf ratio
hflfmax = 10
# example subject for the spectra
subj = 1
if len(sys.argv) > 1:
subj = int(sys.argv[1])
sitting_class = GUDb(subj, 'sitting')
hrv_class = HRV(sitting_class.fs)
lfhf = hrv_class.fAnalysis(sitting_class.anno_cs)
print("Subject sitting: lf/hf=", lfhf)
fig = plt.figure()
fig.suptitle('Subject sitting doing nothing')
# in time
plt.title("Sitting")
plt.subplot(211)
plt.plot(hrv_class.t_hr_linear, hrv_class.hr_linear)
plt.plot(hrv_class.t_hr_discrete, hrv_class.hr_discrete, "x")
plt.xlabel("t/seconds")
plt.ylabel("heartrate/Hz")
# now the Fourier spectrum
plt.subplot(212)
def std_of_successive_diffs(ecg_signal, sample_rate=1000):
hr_analyzer = HRV(sample_rate)
detectors = Detectors(sample_rate)
r_peaks = detectors.hamilton_detector(ecg_signal)
return hr_analyzer.SDSD(r_peaks)
def rms_of_successive_diffs(ecg_signal, sample_rate=1000):
hr_analyzer = HRV(sample_rate)
detectors = Detectors(sample_rate)
r_peaks = detectors.hamilton_detector(ecg_signal)
return hr_analyzer.RMSSD(r_peaks, normalise=False)
def mean_hr(ecg_signal, sample_rate=1000):
hr_analyzer = HRV(sample_rate)
detectors = Detectors(sample_rate)
r_peaks = detectors.hamilton_detector(ecg_signal)
heart_r = hr_analyzer.HR(r_peaks)
return np.mean(heart_r)