def process(self):
rpeaks = bioecg.ecg(np.ravel(self.record),
show=False,
sampling_rate=self.fs)
median_rr = self.calculate_rr(rpeaks)
cycles = self.segment_cycles(rpeaks, median_rr)
return rpeaks, median_rr, cycles
def get_rpeaks(ecg_df, fs):
rpeaks_window = float(fs) * WINDOW_SIZE
rpeaks = []
clean_rpeaks = []
for lead_id in LEADS:
record = ecg_df[lead_id].values
ecg_info = ecg.ecg(record, sampling_rate=fs, show=False)
ecg_rpeaks = ecg_info['rpeaks']
rpeaks.extend(ecg_rpeaks.tolist())
rpeaks = sorted(rpeaks)
rpeaks_area_counter = []
for current_rpreak in rpeaks:
counter=0
for rpreak in rpeaks:
if abs(rpreak - current_rpreak) < rpeaks_window:
counter+=1
rpeaks_area_counter.append(counter)
rpeaks_area_counter = np.array(rpeaks_area_counter)
good_peaks_ids = np.where(rpeaks_area_counter >= 2)[0]
rpeaks = np.array(rpeaks)
good_rpeaks = rpeaks[good_peaks_ids]
clean_rpeaks.append(good_rpeaks[0])
for rpeak_id in range(1, good_rpeaks.shape[0]):
if abs(good_rpeaks[rpeak_id] - clean_rpeaks[-1]) > rpeaks_window:
clean_rpeaks.append(good_rpeaks[rpeak_id])
return np.array(clean_rpeaks)
def get_pulse2(ecgin):
bf = sig.butter(5, [0.1, 10], btype='bandpass', fs=256, output='sos')
out1 = ecg.ecg(signal=ecgin, sampling_rate=256)
# out2 = ecg.ecg(signal=sig.sosfilt(bf, ecgin), sampling_rate=256)
pp.plot(out1['heart_rate_ts'], out1['heart_rate'])
# pp.plot(out2['heart_rate_ts'], out2['heart_rate'])
pp.show()
print(out1['heart_rate_ts'][1:]-out1['heart_rate_ts'][:-1])
def transform_ecg(signal, sampling_rate=SAMPLING_RATE, verbose=False):
signal = signal[~np.isnan(signal)]
X = list()
ts, filtered, rpeaks, templates_ts, templates, heart_rate_ts, heart_rate = ecg.ecg(
signal, sampling_rate, show=verbose)
rpeaks = ecg.correct_rpeaks(signal=signal,
rpeaks=rpeaks,
sampling_rate=sampling_rate,
tol=0.1)
peaks = signal[rpeaks]
if len(heart_rate) < 2:
heart_rate = [0, 1]
if len(heart_rate_ts) < 2:
heart_rate_ts = [0, 1]
X.append(np.mean(peaks))
X.append(np.min(peaks))
X.append(np.max(peaks))
X.append(np.mean(np.diff(rpeaks)))
X.append(np.min(np.diff(rpeaks)))
X.append(np.max(np.diff(rpeaks)))
X.append(np.mean(heart_rate))
X.append(np.min(heart_rate))
X.append(np.max(heart_rate))
X.append(np.mean(np.diff(heart_rate)))
X.append(np.min(np.diff(heart_rate)))
X.append(np.max(np.diff(heart_rate)))
X.append(np.mean(np.diff(heart_rate_ts)))
X.append(np.min(np.diff(heart_rate_ts)))
X.append(np.min(np.diff(heart_rate_ts)))
X.append(np.max(np.diff(heart_rate_ts)))
X.append(np.sum(filtered - signal))
X += list(np.mean(templates, axis=0))
X += list(np.min(templates, axis=0))
X += list(np.max(templates, axis=0))
X = np.array(X)
X[np.isnan(X)] = 0
return np.array(X)
def process(self):
out_tuple = bioecg.ecg(np.ravel(self.record),
show=False,
sampling_rate=self.fs)
return out_tuple['filtered']
def get_pulse(ecgin):
out = ecg.ecg(signal=ecgin, sampling_rate=256, show=False)
return out
def extract_ecg_features(ecgFile, ecgFeatFile, freq, stage, winSize, shift):
threshold = 0.2 # threshold for invalid window Ex) 0.2 represents 20%
numOfFeatures = 8
windowList = []
window_begin = -1
invalid_cnt = 0
valid_cnt = 0
firstTime = -1
firstRead = 0
while True:
line = ecgFile.readline() # 라인 by 라인으로 데이터 읽어오기
if not line:
# print(" End Of Zep ECG File")
break
lineData = [x.strip() for x in line.split(',')] # 데이터 한 줄을 리스트로 변환
currentTime = float(lineData[0])
if firstRead == 0:
firstTime = currentTime
firstRead = 1
if firstTime + shift <= currentTime:
if window_begin == -1:
window_begin = currentTime
if lineData[1] != '':
windowList.append(float(lineData[1]))
valid_cnt += 1
else:
invalid_cnt += 1
if currentTime - window_begin >= winSize:
features = []
if invalid_cnt <= (
(winSize * freq) * threshold): # valid window
try:
window = ecg.ecg(signal=windowList,
sampling_rate=freq,
show=False)
except ValueError:
for i in range(0, numOfFeatures):
features.append('n\t')
else:
# Calculate RR intervals
rrList = []
for i in range(1, len(window[2])):
rr = window[0][window[2][i]] - window[0][window[2][
i - 1]]
rrList.append(rr)
# Calculate RMSSD that is heart rate variability (HRV)
hrvList = [0]
if rrList:
if len(rrList) > 1:
hrvList = []
for y in range(len(rrList) - 1):
hrvList.append(
(rrList[y + 1] - rrList[y]) *
(rrList[y + 1] - rrList[y]))
try:
freqDomFeat = frequencyDomain(rrList,
band_type=None,
lf_bw=0.11,
hf_bw=0.1,
plot=0)
except ValueError:
freqDomFeat = [0, 0, 0, 0]
# min-per20-med-per80-max-mean-std-hrv
# vlfe-lfe-hfe-lfhfr
features.append(
str(np.min(rrList)) + "\t" +
str(np.percentile(rrList, 20)) + "\t" +
str(np.median(rrList)) + "\t" +
str(np.percentile(rrList, 80)) + "\t" +
str(np.max(rrList)) + "\t" + str(np.mean(rrList)) +
"\t" + str(np.std(rrList)) + "\t" +
str(np.sqrt(np.average(hrvList))) + "\t")
# + "\t" + str(freqDomFeat[0]) + "\t" + str(freqDomFeat[1]) + "\t" + str(freqDomFeat[2]) + "\t" + str(freqDomFeat[3])
else: # equal to or more than 20% error? no features. that is invalid window
for i in range(0, numOfFeatures):
features.append('n\t')
features.append(stage + '\n')
ecgFeatFile.write(''.join(features))
windowList = []
window_begin = -1
valid_cnt = 0
invalid_cnt = 0
print('X_t shape: ' + str(X_t.shape))
print('y_t shape: ' + str(y_t.shape))
loaded_model = load_model('autoencoder.h5')
encoder = Model(loaded_model.input,
loaded_model.layers[-3].input) # Input(shape=(180,))
encoded_matrix = []
for row in X_t:
decomposed_row = np.empty([1, 180]) # initializing meaningless line
row = pd.Series(row)
row = row.dropna().values
_, _, _, _, templates, _, _ = ecg.ecg(signal=row,
sampling_rate=300.0,
show=False)
decomposed_row = np.concatenate((decomposed_row, templates), axis=0)
decomposed_row = decomposed_row[1:] # removing meaningless line
decomposed_encoded_row = []
for beat in decomposed_row:
decomposed_encoded_row.append(encoder.predict(np.array([beat]))[0])
encoded_matrix.append(np.array(decomposed_encoded_row))
encoded_matrix = np.array(encoded_matrix)
print(encoded_matrix.shape)
print('Computed encoded matrix')
X_train, X_test, y_train, y_test = train_test_split(encoded_matrix,
y_t,
test_size=0.2)
import matplotlib as ml
import matplotlib.pyplot as plt
#bdfRec = bdfRecording("../Dataset/Sessions/789/Part_7_N_Trial5_emotion.bdf")
bdfRec = bdfRecording("789/Part_7_N_Trial5_emotion.bdf")
ECG_idx = bdfRec.dataChanLabels.index('EXG2')
rec = bdfRec.getData(channels=[ECG_idx])
sampling_rate = bdfRec.sampRate[ECG_idx]
signal = np.array(rec['data'][0])
rec_s = pd.Series(rec['data'][0])
rec_s.plot()
pyplot.pause(0.1)
hr = ecg.ecg(signal=signal, sampling_rate=sampling_rate, show=False)[6]
#Must figure out a better way to find the time table.
#Video is 22 seconds and there is 85 samples
#video_duration = 22
#step = video_duration/float(len(hr))
step = 1/(float(sampling_rate)/60)
length = len(hr)
video_duration = step * float(len(hr))
time_array = np.arange(0, video_duration, step)
time_array_len = len(time_array)
combined = np.vstack((time_array, hr)).T
np.savetxt("ecg.csv", combined, delimiter=",")