def find_peaks(self, X, channel=0):
X_processed = X[:, channel].copy()
X_processed = filter_signal(signal=X_processed,
ftype='FIR',
band='bandpass',
order=150,
frequency=[3, 45],
sampling_rate=400)[0]
# check original polarity
ecg_object = ecg.ecg(signal=X_processed, sampling_rate=400, show=False)
peaks_plus = ecg_object['rpeaks'] # rpeak indices
# check reversed polarity
ecg_object = ecg.ecg(signal=-1 * X_processed,
sampling_rate=400,
show=False)
peaks_minus = ecg_object['rpeaks'] #
# select polarity
if np.abs(np.median(X_processed[peaks_minus])) > np.abs(
np.median(X_processed[peaks_plus])):
peaks = peaks_minus.copy()
else:
peaks = peaks_plus.copy()
return peaks
def peaksAndAveraged(signal, visibility):
forTemplates = ecg.ecg(signal, sampling_rate=Fs, show=visibility)
forPeaks = ecg.ecg(signal, sampling_rate=Fs, show=visibility)
rpeaks = forPeaks['rpeaks']
templates = forTemplates['templates']
average_final = np.average(templates, axis=0)
return rpeaks, average_final, templates
def process(X):
features = []
for i in range(len(X)):
_sample = X[i]
print(f"sample {i}: Class {y[i]}")
sample = _sample[~np.isnan(_sample)]
res = ecg(signal=sample, sampling_rate=300, show=False)
median = calc_median(res["templates"])
# if (np.argmin(median) < 60) and not 0.7*np.max(median) > abs(np.min(median)):
if (not np.max(median[55:65]) == np.max(median)
or (np.max(median) < -0.8 * np.min(median))
or (not 0.75 * np.max(median) > -np.min(median) and
(np.argmin(median) < 60 and
(np.min(median[:60]) < 1.5 * min(median[60:])
or np.min(median[60:]) < 1.5 * min(median[:60]))))):
# and ((np.min(median) < 1.2 * np.min(
# median[[i for i in range(len(median)) if i != np.argmin(median)]])) or np.max(median[45:48]) > -np.min(median[65:75])):
# if np.min(median[45:55]) < np.min(median[0:45]) and np.min(median[65:80]) < np.min(median[80:]) and np.max(median[55:65]) == np.max(median):
# if np.max(median) < abs(np.min(median)) and np.min(median[50:55]) < np.min(median[60:65]):
# if abs(np.mean(median)) > abs(np.median(median)):
res = ecg(-sample, sampling_rate=300, show=False)
# plt.plot(rdiffs)
# plt.show()
features.append(np.array(res["templates"]).flatten())
features = pd.DataFrame(features)
print(f"computed features {features.shape}")
return features
def get_ecg_db():
data = []
max_R = 2.0
min_S = -1.3
for k in range(1, 91):
if k in [5, 6, 11, 14, 20, 21, 22, 40, 48, 49, 71, 74, 79, 84, 88, 90]:
continue
#Получение данных с сайта
if k < 10:
record = wfdb.rdrecord('rec_1', pb_dir='ecgiddb/Person_0{0}/'.format(k), sampto=SAMPTO, channels=[0])
record2 = wfdb.rdrecord('rec_2', pb_dir='ecgiddb/Person_0{0}/'.format(k), sampto=SAMPTO, channels=[0])
else:
record = wfdb.rdrecord('rec_1', pb_dir='ecgiddb/Person_{0}/'.format(k), sampto=SAMPTO, channels=[0])
record2 = wfdb.rdrecord('rec_2', pb_dir='ecgiddb/Person_{0}/'.format(k), sampto=SAMPTO, channels=[0])
#Преобразование данных к списку
sig = [record.p_signal[i][0] for i in range(len(record.p_signal))]
sig2 = [record2.p_signal[i][0] for i in range(len(record2.p_signal))]
#обработка сигнала
out = ecg.ecg(signal=sig, sampling_rate=500., show=False)
out2 = ecg.ecg(signal=sig2, sampling_rate=500., show=False)
#Обработанный сигнал
filtered = list(out[1])
filtered.extend(list(out2[1]))
i = 0
P = []
Q = []
R = list(out[2])
R.extend([list(out2[2])[i] + 10000 for i in range(len(list(out2[2])))])
S = []
T = []
'''
plt.plot([i for i in range(20000)], filtered)
plt.plot(R, [filtered[i] for i in R], 'ro')
plt.show()
'''
for r in R:
if i == len(R) - 1:
break
dx = (R[i+1] - r) / 2
min_x = int(r - dx) if (r-dx > 0) else 0
max_x = int(r + dx)
q_ = indexOfMinElement(filtered[min_x:r]) + min_x
Q.append(q_)
s_ = indexOfMinElement(filtered[r:max_x]) + r
S.append(s_)
P.append(indexOfMaxElement(filtered[min_x:q_]) + min_x)
T.append(indexOfMaxElement(filtered[s_:max_x]) + s_)
i += 1
del R[-1]
max_R = max([filtered[j] for j in R]) if max([filtered[j] for j in R]) > max_R else max_R
min_S = min([filtered[j] for j in S]) if min([filtered[j] for j in S]) < min_S else min_S
print("max R -> {0:.4f}, min_S -> {1:.4f}".format(max_R, min_S))
person_data = QRS(P, [filtered[j] for j in P],
Q, [filtered[j] for j in Q],
R, [filtered[j] for j in R],
S, [filtered[j] for j in S],
T, [filtered[j] for j in T])
data.append(person_data)
print("Info with QRS of {0} person added".format(k))
return data
def process_mit_arrhythmia(data_path):
record_ids = list(
map(lambda x: x.split('.')[0],
list(filter(lambda x: x.endswith('.dat'), os.listdir(data_path)))))
for idx in tqdm(record_ids):
record = wfdb.rdrecord(os.path.join(data_path, idx))
annotation = wfdb.rdann(os.path.join(data_path, idx), 'atr')
signal_ch1 = record.p_signal[:, 0]
signal_ch2 = record.p_signal[:, 0]
ecg_ch1 = ecg.ecg(signal=signal_ch1,
sampling_rate=record.fs,
show=False)
ecg_ch2 = ecg.ecg(signal=signal_ch2,
sampling_rate=record.fs,
show=False)
# Smooth signals
signal_smoothed_ch1 = ecg_ch1['filtered']
signal_smoothed_ch2 = ecg_ch2['filtered']
# Reading r-peaks
r_peaks = ecg_ch1['rpeaks']
# Reading annotations. `symbol` and `sample` are labels and values respectively.
ann_symbol = annotation.symbol
ann_sample = annotation.sample
print(signal_ch1.shape, ann_sample, ann_symbol, r_peaks)
def getResults(self):
global data, results, rpeaks, sample_rate
if self.results_whole.isChecked():
filt, rpeaks = ecg(signal=data,
sampling_rate=sample_rate,
show=False)[1:3]
self.plotPeaks(data, rpeaks)
rpeaks = rpeaks / sample_rate
nni = tools.nn_intervals(rpeaks=rpeaks)
results = hrv(nni=nni,
rpeaks=rpeaks,
sampling_rate=sample_rate,
interval=[0, int(len(data) / sample_rate)],
show=False)
self.showPlots()
self.time_domain_txt()
s = str(folder + '/time_domain.txt')
text = open(s).read()
self.time_txt.setPlainText(text)
self.freq_domain_txt()
s = str(folder + '/frequency_domain.txt')
text = open(s).read()
self.freq_txt.setPlainText(text)
self.nonlin_domain_txt()
s = str(folder + '/nonlinear_domain.txt')
text = open(s).read()
self.nonlin_txt.setPlainText(text)
elif self.results_part.isChecked():
limits = self.lr.getRegion()
x = int(limits[0] * sample_rate)
y = int(limits[1] * sample_rate)
if x < 0:
signal_t = data[0:y]
elif y > len(data):
signal_t = data[x:]
else:
signal_t = data[x:y]
filt, rpeaks = ecg(signal=signal_t,
sampling_rate=sample_rate,
show=False)[1:3]
self.plotPeaks(signal_t, rpeaks)
rpeaks = rpeaks / sample_rate
nni = tools.nn_intervals(rpeaks=rpeaks)
results = hrv(nni=nni,
rpeaks=rpeaks,
sampling_rate=sample_rate,
interval=[0, int(len(signal_t) / sample_rate)],
show=False)
self.showPlots()
else:
self.showMsg(
'Please select if you want HRV parameters for whole signal or for selected part'
)
def signal_handler(signum, frame):
id_time = str(int(time.time()))
ecg.ecg(signal = participant1.ecg_data, sampling_rate = SamplingRate, show=False)
np.savetxt('files/biosppy_bitalino/biotetris_mainECG1_' + id_time + '.txt', participant1.data_file, fmt="%s")
ecg.ecg(signal = participant2.ecg_data, sampling_rate = SamplingRate, show=False)
np.savetxt('files/biosppy_bitalino/biotetris_mainECG2_' + id_time + '.txt', participant2.data_file, fmt="%s")
print('END OF EXPERIMENT')
sys.exit(0)
def processPatient(patient):
normal_samples = []
abnormal_samples = []
samples = []
record = sio.loadmat(os.path.join(DATA_DIR, str(patient) + ".mat"))
annotation = sio.loadmat(os.path.join(DATA_DIR, str(patient) + "ann.mat"))
if patient == 114: # patient 114 record's mlii in lead B
sig = record["signal"][:, 1]
sig2 = record["signal"][:, 0]
else: # others' in lead A
sig = record["signal"][:, 0]
sig2 = record["signal"][:, 1]
assert len(sig) == len(sig2)
sig_out = ecg.ecg(signal=sig, sampling_rate=360., show=False)
sig = sig_out["filtered"]
sig2 = ecg.ecg(signal=sig2, sampling_rate=360., show=False)["filtered"]
r_peaks = sig_out["rpeaks"]
ts = record["tm"]
ann_types = annotation["type"]
ann_signal_idx = annotation["ann"]
for ann_idx, ann_type in enumerate(ann_types):
if ann_type in BEAT:
sig_idx = ann_signal_idx[ann_idx][0]
if sig_idx - LEFT >= 0 and sig_idx + RIGHT < len(sig):
if ann_type in N:
closed_rpeak_idx = bisearch(sig_idx, r_peaks)
if abs(closed_rpeak_idx - sig_idx) < 10:
# normal_samples.append((sig[sig_idx-LEFT:sig_idx+RIGHT],ann_type))
samples.append(([
sig[sig_idx - LEFT:sig_idx + RIGHT],
sig2[sig_idx - LEFT:sig_idx + RIGHT]
], 'N', ann_type))
else:
# abnormal_samples.append((sig[sig_idx-LEFT:sig_idx+RIGHT],ann_type))
AAMI_label = ""
if ann_type in S:
AAMI_label = "S"
elif ann_type in V:
AAMI_label = "V"
elif ann_type in F:
AAMI_label = "F"
elif ann_type in Q:
AAMI_label = "Q"
else:
raise Exception("annonation type error")
assert AAMI_label != ""
samples.append(([
sig[sig_idx - LEFT:sig_idx + RIGHT],
sig2[sig_idx - LEFT:sig_idx + RIGHT]
], AAMI_label, ann_type))
return np.array(samples)
def peaksAndAveraged(signal, visibility):
forTemplates = ecg.ecg(signal, sampling_rate=Fs, show=visibility)
filtered = signal
# filtered = highFilter(signal, Fs, 5)
# filtered = lowFilter(filtered, Fs, 15)
forPeaks = ecg.ecg(filtered, sampling_rate=Fs, show=visibility)
# rpeaks = ecg.hamilton_segmenter(filtered, Fs)
rpeaks = forPeaks['rpeaks']
templates = forTemplates['templates']
average_final = np.average(templates, axis=0)
return rpeaks, average_final, templates
def visualise_all(filename, nparray):
"""
:param filename: str, filename to save the plot
:param nparray: nparray, input numpy array what biosppy lib use
:return: None
"""
# load raw ECG signal
signal = nparray
# process it and save the plot (changed function in source lib)
full_path = path + '/' + filename
ecg.ecg(signal=signal, sampling_rate=300., show=False, path=full_path)
add_to_log('Complex plot saved at {}'.format(full_path))
def process(X):
Fs = 300
templates = {}
templates_var = {}
the_heartbeats = {}
data = X
nsamples = data.shape[0]
for i in range(data.shape[0]):
if not i % 50: #print message every 50 samples
print('preprocessed {} / {} samples'.format(i, nsamples))
signal1 = data.iloc[i].dropna().values
out = ecg.ecg(signal=signal1, sampling_rate=Fs, show=False)
templates[data.iloc[i].name] = out['templates'].mean(0)
templates_var[data.iloc[i].name] = out['templates'].var(0)
the_heartbeats[data.iloc[i].name] = out['heart_rate']
#heartbeat teamplate's mean and variance at each time step
templatesDF = pd.DataFrame(templates).T
templatesDF.index = data.index
templates_varDF = pd.DataFrame(templates_var).T
templates_varDF.index = data.index
#heartbeat rate's mean and variance
hbs = [[heartbeats.mean(), heartbeats.var()]
for (i, heartbeats) in the_heartbeats.items()]
hbsDF = pd.DataFrame(hbs)
hbsDF.columns = ['heartbeats mean', 'heartbeats variance']
hbsDF.index = data.index
X_ = pd.merge(templatesDF,
templates_varDF,
left_index=True,
right_index=True)
X_ = pd.merge(hbsDF, X_, left_index=True, right_index=True)
return X_
def setup(self):
ecg_signal = electrocardiogram()
ecg_signal = ecg_signal - np.mean(ecg_signal)
(ts, filtered, rpeaks, templates_ts, templates, heart_rate_ts,
heart_rate) = ecg.ecg(signal=ecg_signal,
sampling_rate=360,
show=False)
my_ecg = fb.ECG(input_signal=filtered,
indicators=rpeaks,
is_filtered=False)
list_ecg = my_ecg.buildPackets(25)
norm_parameter = list(
zip(np.linspace(3, 13, 10), np.linspace(3, 13, 10)))
norm_lenght = list(zip(np.linspace(15, 20, 5), np.linspace(15, 20, 5)))
parameter = list(zip(np.linspace(3, 13, 10), np.linspace(3, 13, 10)))
lenght = list(zip(np.linspace(15, 20, 5), np.linspace(15, 20, 5)))
template_gaussian = fb.TemplateEvaluetor(fb.Gaussian(), norm_parameter,
norm_lenght)
template_mexican = fb.TemplateEvaluetor(fb.MexicanHat(), parameter,
lenght)
template_rayleigh = fb.TemplateEvaluetor(fb.Rayleigh(), parameter,
lenght)
template_left_rayleigh = fb.TemplateEvaluetor(fb.LeftInverseRayleigh(),
parameter, lenght)
template_right_rayleigh = fb.TemplateEvaluetor(
fb.RightInverseRayleigh(), parameter, lenght)
list_of_templates = [
template_gaussian, template_mexican, template_rayleigh,
template_left_rayleigh, template_right_rayleigh
]
def ecg_dash(request, pk):
signal = Signal.objects.get(pk=pk)
try:
descripcion = signal.descripcionecg_set.all()[0]
bpm = descripcion.bpm
print(descripcion)
except:
try:
from biosppy.signals import ecg
info = signal.datasenal_set.all()[0]
proces = ecg.ecg(signal=info.data,
sampling_rate=info.frecuencia,
show=False)
hrate = proces[6]
bpm = int(sum(hrate) / len(hrate))
descripcion = Descripcionecg(senal=signal,
filtrada=proces[1],
hrv=proces[6],
bpm=bpm)
descripcion.save()
print(descripcion.bpm)
except:
bpm = 0
return render(request, 'ecg/senales/ecg_dash.html', {
'signal': signal,
'bpm': bpm
})
def cutf(self):
global flag_obelezi, rpeaks, sample_rate, pre, data
if self.view_tab.currentIndex() == 0:
plot = self.view_signal
else:
plot = self.tachogram_view
self.redo.setEnabled(False)
self.undo.setEnabled(True)
limits = self.lr.getRegion()
pre = data
x = int(limits[0] * sample_rate)
y = int(limits[1] * sample_rate)
if x < 0:
data = pre[y:]
elif y > len(data):
data = pre[0:x]
else:
a = pre[0:x]
b = pre[y:]
data = np.concatenate((a, b))
plot.removeItem(self.lr)
flag_obelezi = 0
filt, rpeaks = ecg(signal=data, sampling_rate=sample_rate,
show=False)[1:3]
self.update()
self.cut.setEnabled(False)
self.select.setDisabled(False)
def aggregateHeartbeats(data, filename):
print("Started with aggregation")
numberOfPatients = data.shape[0]
averagedHeartBeats = np.empty([numberOfPatients, 180])
for i in range(numberOfPatients):
currentPatient = data.iloc[i]
currentPatient = currentPatient.dropna()
currentPatient = currentPatient.values
#rpeaks_ = ecg.correct_rpeaks(currentPatient, )
ts, filtered, rpeaks, templates_ts, templates, heart_rate_ts, heart_rate = ecg.ecg(
currentPatient, sampling_rate=300, show=False)
#rpeaks_ = ecg.hamilton_segmenter(filtered, sampling_rate=300)
#rpeaks_ = ecg.gamboa_segmenter(currentPatient, rpeaks_, sampling_rate=300)
#templates, rpeaks_ = ecg.extract_heartbeats(currentPatient, rpeaks = rpeaks_, sampling_rate=300)
print("shape before summing out:", templates.shape)
if templates.shape[1] != 180:
print("anasini sikim boyle datanin")
templates = np.sum(templates, axis=0) / templates.shape[0]
print("shape after summing out:", templates.shape)
averagedHeartBeats[i] = templates
print("Shape of averaged heartbeats: ", averagedHeartBeats.shape)
np.save(filename, averagedHeartBeats)
def getRateChange_Max(task, index, output, samp_rate):
vals = []
# making sure we are able to get values whether or not they are in a
# two-dimensional array
for i in range(len(task)):
try:
vals.append(task[i][index])
except:
vals.append(task[i])
# vals array is raw data
vals = filter(lambda x: x != "", vals) # remove empty strings
# extract heartrate using biosppy
# vals is raw ECG data
out = ecg.ecg(signal=vals, sampling_rate=samp_rate, show=False)
# indexed number corresponds to the returned tuples from out
# check biosppy files for more info
out_heart_rate = out[6].tolist() # using numpy, convert ndarry into a list
# look through the formed heart rate list and find the changes in rate
# create a new list with the rates of change
# output the highest rate of change
hr_changes = []
for i in range(len(out_heart_rate)):
rate_change = out_heart_rate[i] - out_heart_rate[i - 1]
hr_changes.append(rate_change)
maximum = str(max(hr_changes))
output.write(maximum + ', ')
def lead_search_fun(signal_data):
"""""
Calculate Lead with highest T-Peak
Parameters:
----------
signal_data: np.array ECG signal
Returns:
---------
lead: int highest Lead
""" ""
t_value = np.zeros(6)
counter = 0
leads = [0, 1, 8, 9, 10, 11]
for i in leads:
# next high point after S-Peak
try:
ecg_lead = ecg.ecg(signal_data[i, 0:1500],
sampling_rate=500,
show=False)
search_area_blr = remove_baseline_fun(signal_data[i, 0:1500], 500)
s_index = np.argmin(
search_area_blr[ecg_lead["rpeaks"][0]:ecg_lead["rpeaks"][0] +
50]) + ecg_lead["rpeaks"][0]
t_index = np.argmax(
search_area_blr[s_index:ecg_lead["rpeaks"][1] - 20]) + s_index
t_value[counter] = search_area_blr[t_index + 5]
except ValueError:
t_value[counter] = 0
counter += 1
return leads[np.argmax(t_value)]
def features_from_raw_data(data):
features = []
cnt = 0
for series in data:
print(str(cnt))
cnt += 1
# print (series)
# Todo: Check this conversion!!!
series = series[np.logical_not(np.isnan(series))]
# print (series)
# print (series.shape)
# series = series[np.bitwise.isnan(series)]
out = ecg.ecg(series, sampling_rate=300, show=False)
filtered = np.array(out[1]) # Filtered ECG signal. (ARRAY)
rpeaks = np.array(out[2]) # R-peak location indices (ARRAY)
templates = np.array(out[4]) # Extracted heartbeat templates. (ARRAY OF ARRAY)
heart_rate = np.array(out[6]) # Instantaneous heart rate (bpm). (ARRAY)
# print(filtered)
# print(rpeaks)
# print(templates.shape)
# print(heart_rate)
series_features = [] # ARRAY [series info..., filtered info..., heartrate info..., peak dist info..., template info...]
# #extrahiere aus jedem 1d array featurevector
# for info in [series, filtered, heart_rate, rpeaks[1:] - rpeaks[:-1]]: #letzte ist abst., zw. peaks
# if info.shape[0] == 0:
# series_features.extend([0, 0, 0, 0, 0, 0])
# else:
# series_features.extend(
# [
# np.mean(info), np.var(info), np.median(info),
# np.amin(info), np.amax(info), np.amax(info) - np.amin(info)
# ]
# )
# #array of arrays, immer features au 0,1,2,... position (ueber collom)
# series_features.extend(np.mean(templates, axis=0).tolist())
# series_features.extend(np.var(templates, axis=0).tolist())
# series_features.extend(np.median(templates, axis=0).tolist())
# series_features.extend(np.amin(templates, axis=0).tolist())
# series_features.extend(np.amax(templates, axis=0).tolist())
template_values = []
for i in range(templates.shape[0]):
template_values.append(extract_template_info(templates[i, :]))
template_values = np.vstack(template_values)
series_features.extend(np.mean(template_values, axis=0).tolist())
series_features.extend(np.var(template_values, axis=0).tolist())
series_features.extend(np.median(template_values, axis=0).tolist())
series_features.extend(np.amin(template_values, axis=0).tolist())
series_features.extend(np.amax(template_values, axis=0).tolist())
mean_template = np.mean(templates, axis=0)
series_features.extend(extract_template_info(mean_template).tolist())
features.append(np.array(series_features))
return np.vstack(features)
def detect_r_points(signal, length, rate, algorithm='none'):
length = signal.shape[0]
ecg_out = ecg.ecg(signal=signal[:, 0], sampling_rate=rate, show=False)
filtered = ecg_out.__getitem__('filtered')
temp_rpeaks = ecg_out.__getitem__('rpeaks')
#engzee_out = ecg.engzee_segmenter(signal=filtered, sampling_rate=rate)
#temp_rpeaks = engzee_out.__getitem__('rpeaks')
#try:
rpeaks = np.empty([temp_rpeaks.shape[0], 1], dtype=int)
for i, r in enumerate(temp_rpeaks):
#find maximum
rpeaks[i] = r
max_best_so_far = r
end = False
#while not end:
#end = True
for j in range(25):
neighbor1 = max_best_so_far - j
neighbor2 = max_best_so_far + j
if abs(signal[neighbor1]) > abs(signal[max_best_so_far]):
max_best_so_far = neighbor1
#end = False
if abs(signal[neighbor2]) > abs(signal[max_best_so_far]):
max_best_so_far = neighbor2
#end = False
rpeaks[i] = max_best_so_far
print('finished finalizing r points! :)')
#except:
# print('Biosppy error (Not enough beats to compute heart rate :?)')
return rpeaks
def __heartbeats(X=None, verbose=False, precomputed=None):
if precomputed == 'train':
X_new = pd.read_csv('../../Data/heartbeat_feat_train.csv').drop(
'id', 1)
elif precomputed == 'test':
X_new = pd.read_csv('../../Data/heartbeat_feat_test.csv').drop('id', 1)
else:
X_new = []
for index, row in X.iterrows():
_, _, peaks, _, templates, _, _ = ecg.ecg(signal=row.dropna(),
sampling_rate=300.0,
show=False)
#get one averaged heartbeat template for each time series
average = np.mean(templates, axis=0)
#calculate the variances of the heartbeat templates for a selected number of points (evenly distributed)
sel_templates = templates[np.round(
np.linspace(0,
len(templates) - 1, 20)).astype(int)]
variances = np.var(sel_templates, axis=0)
#calculate the distances between r-peaks
peaks_distances = np.diff(peaks)
mean_peaks_distances = np.mean(peaks_distances)
var_peaks_distances = np.var(peaks_distances)
features = np.concatenate([
average, variances,
[mean_peaks_distances, var_peaks_distances]
])
X_new.append(features)
if verbose and index % 100 == 0:
print(index)
print(X_new)
#X_new = pd.concat(X_new, ignore_index=True)
X_new = pd.DataFrame(X_new)
return X_new
def getRateChange_Max(task,index,output,samp_rate):
vals = []
# making sure we are able to get values whether or not they are in a
# two-dimensional array
for i in range(len(task)):
try:
vals.append(task[i][index])
except:
vals.append(task[i])
# vals array is raw data
vals = filter(lambda x:x !="", vals) # remove empty strings
# extract heartrate using biosppy
# vals is raw ECG data
out = ecg.ecg(signal=vals, sampling_rate=samp_rate, show=False)
# indexed number corresponds to the returned tuples from out
# check biosppy files for more info
out_heart_rate = out[6].tolist() # using numpy, convert ndarry into a list
# look through the formed heart rate list and find the changes in rate
# create a new list with the rates of change
# output the highest rate of change
hr_changes = []
for i in range(len(out_heart_rate)):
rate_change = out_heart_rate[i] - out_heart_rate[i-1]
hr_changes.append(rate_change)
maximum = str(max(hr_changes))
output.write(maximum + ', ')
def transform(self, X, y=None):
X_new = [
ecg.ecg(signal=X[i, :], sampling_rate=self.srate, show=False)
for i in range(self.n_samples)
]
return X_new
def rri_test_recurrent(filelist=None):
global shape_tmp
for i in range(len(filelist)):
# for i in range(10):
with open(filelist[i], 'rb') as f:
plk_tmp = pkl.load(f)
ecg_re = ecg.ecg(signal=plk_tmp, sampling_rate=Fs, show=False)
rpeaks_tmp = ecg_re['rpeaks'].tolist()
nni = tools.nn_intervals(rpeaks=rpeaks_tmp)
nni_tmp = nni.reshape((-1, int(nni.shape[0]))) # for 2d data type
rp = RecurrencePlot(threshold='point', percentage=20)
X_rp = rp.fit_transform(nni_tmp)
dst = cv2.resize(X_rp[0],
dsize=(135, 135),
interpolation=cv2.INTER_AREA)
shape_tmp.append(X_rp.shape)
recurrence_tmp.append(X_rp)
recur_resize.append(dst)
# for pandas
# shape_tmp = shape_tmp.append(pd.DataFrame(X_rp.shape))
# plot check
plt.imshow(X_rp[0], cmap='binary', origin='lower')
plt.plot(nni)
plt.title('Recurrence Plot', fontsize=16)
plt.tight_layout()
plt.show()
# np_tmp = np.column_stack([np_tmp, X_rp])
if i == 0:
pass
return shape_tmp, recurrence_tmp, np.asarray(recur_resize)
def _preprocess_signal(self, signal_raw, filter_bandwidth, normalize, polarity_check,
template_before, template_after):
# Filter signal
signal_filtered = self._apply_filter(signal_raw, filter_bandwidth)
# Get BioSPPy ECG object
ecg_object = ecg.ecg(signal=signal_raw, sampling_rate=self.fs, show=False)
# Get BioSPPy output
ts = ecg_object['ts'] # Signal time array
rpeaks = ecg_object['rpeaks'] # rpeak indices
# Get templates and template time array
templates, rpeaks = self._extract_templates(signal_filtered, rpeaks, template_before, template_after)
templates_ts = np.linspace(-template_before, template_after, templates.shape[1], endpoint=False)
# Polarity check
signal_raw, signal_filtered, templates = self._check_waveform_polarity(polarity_check=polarity_check,
signal_raw=signal_raw,
signal_filtered=signal_filtered,
templates=templates)
# Normalize waveform
signal_raw, signal_filtered, templates = self._normalize_waveform_amplitude(normalize=normalize,
signal_raw=signal_raw,
signal_filtered=signal_filtered,
templates=templates)
return ts, signal_raw, signal_filtered, rpeaks, templates_ts, templates
def main():
print()
print('***************By Killer Queen***************')
# configs:
X_train_dir = './data/x_train.npy'
X_test_dir = './data/x_test.npy'
x_train = np.load(X_train_dir)
x_test = np.load(X_test_dir)
sample_rate = 300
save_prefix = ['train', 'test']
for i, set in enumerate([x_train, x_test]):
for j in tqdm.tqdm(range(len(set))):
x = set[j]
x = x[~np.isnan(x)]
out = ecg.ecg(x, sampling_rate=sample_rate, show=False)
S_point, Q_point = QS_detect(out[1], 300, out[2], False)
np.savez('./data/{}_{}'.format(save_prefix[i], j),
ts=np.array(out[0]),
filtered=np.array(out[1]),
rpeaks=np.array(out[2]),
templates_ts=np.array(out[3]),
templates=np.array(out[4]),
heart_rate_ts=np.array(out[5]),
heart_rate=np.array(out[6]),
s_points=S_point,
q_points=Q_point)
"""
def ecg_preprocessing(signals):
''' Preprocessing for ECG signals '''
# some data have high peak value due to noise
# signals , _ = detrend(signals)
signals = butter_highpass_filter(signals, 1.0, 128.0)
ecg_all = ecg.ecg(signal=signals, sampling_rate=128., show=False)
rpeaks = ecg_all['rpeaks'] # R-peak location indices.
# ECG
freqs, power = getfreqs_power(signals,
fs=128.,
nperseg=signals.size,
scaling='spectrum')
power_0_6 = []
for i in range(60):
power_0_6.append(
getBand_Power(freqs,
power,
lower=0 + (i * 0.1),
upper=0.1 + (i * 0.1)))
IBI = np.array([])
for i in range(len(rpeaks) - 1):
IBI = np.append(IBI, (rpeaks[i + 1] - rpeaks[i]) / 128.0)
heart_rate = np.array([])
for i in range(len(IBI)):
append_value = 60.0 / IBI[i] if IBI[i] != 0 else 0
heart_rate = np.append(heart_rate, append_value)
mean_IBI = np.mean(IBI)
rms_IBI = np.sqrt(np.mean(np.square(IBI)))
std_IBI = np.std(IBI)
skew_IBI = skew(IBI)
kurt_IBI = kurtosis(IBI)
per_above_IBI = float(IBI[IBI > mean_IBI + std_IBI].size) / float(IBI.size)
per_below_IBI = float(IBI[IBI < mean_IBI - std_IBI].size) / float(IBI.size)
# IBI
mean_heart_rate = np.mean(heart_rate)
std_heart_rate = np.std(heart_rate)
skew_heart_rate = skew(heart_rate)
kurt_heart_rate = kurtosis(heart_rate)
per_above_heart_rate = float(heart_rate[heart_rate > mean_heart_rate +
std_heart_rate].size) / float(
heart_rate.size)
per_below_heart_rate = float(heart_rate[heart_rate < mean_heart_rate -
std_heart_rate].size) / float(
heart_rate.size)
features = power_0_6 + [
rms_IBI, mean_IBI, std_IBI, skew_IBI, kurt_IBI, per_above_IBI,
per_below_IBI
] + [
mean_heart_rate, std_heart_rate, skew_heart_rate, kurt_heart_rate,
per_above_heart_rate, per_below_heart_rate
]
return features
def get_features_dict(x):
[ts, fts, rpeaks, tts, thb, hrts,
hr] = ecg.ecg(signal=x, sampling_rate=loader.FREQUENCY, show=False)
"""
Returns:
ts (array) – Signal time axis reference (seconds).
filtered (array) – Filtered ECG signal.
rpeaks (array) – R-peak location indices.
templates_ts (array) – Templates time axis reference (seconds).
templates (array) – Extracted heartbeat templates.
heart_rate_ts (array) – Heart rate time axis reference (seconds).
heart_rate (array) – Instantaneous heart rate (bpm).
"""
fx = dict()
fx.update(heart_rate_features(hr))
fx.update(frequency_powers(x, n_power_features=60))
fx.update(add_suffix(frequency_powers(fts), "fil"))
fx.update(frequency_powers_summary(fts))
fx.update(heart_beats_features2(thb))
fx.update(fft_features(heartbeats.median_heartbeat(thb)))
# fx.update(heart_beats_features3(thb))
fx.update(r_features(fts, rpeaks))
fx['PRbyST'] = fx['PR_interval'] * fx['ST_interval']
fx['P_form'] = fx['P_kurt'] * fx['P_skew']
fx['T_form'] = fx['T_kurt'] * fx['T_skew']
for key, value in fx.items():
if np.math.isnan(value):
value = 0
fx[key] = value
return fx
def get_mat(file_name):
arr = matlab.loadmat(file_name)['val'][0]
# if inverted, invert.
if check_if_inverted(arr):
arr = np.negative(arr)
# use biosppy to filter and get R peaks
out = ecg.ecg(signal=arr, sampling_rate=300., show=False)
return out
def _get_rpeaks(self):
# Get BioSPPy ECG object
ecg_object = ecg.ecg(signal=self.waveform,
sampling_rate=self.fs,
show=False)
return ecg_object['rpeaks']
def peaks_and_averaged(self):
ecg_data = ecg.ecg(self.modified_data,
sampling_rate=self.fsValue,
show=False)
rpeaks = ecg_data['rpeaks']
templates = ecg_data['templates']
average_final = np.average(templates, axis=0)
return rpeaks, average_final, templates
def _get_rpeaks(self):
"""Hamilton-Tompkins r-peak detection."""
# Get BioSPPy ecg object
ecg_object = ecg.ecg(signal=self.waveform,
sampling_rate=self.fs,
show=False)
return ecg_object['rpeaks']
def getHR_Std(task,index,output,samp_rate):
vals = []
for i in range(len(task)):
try:
vals.append(task[i][index])
except:
vals.append(task[i])
vals = filter(lambda x:x !="", vals) # remove empty strings
# extract heartrate using biosppy
# vals is raw ECG data
out = ecg.ecg(signal=vals, sampling_rate=samp_rate, show=False)
# indexed number corresponds to the returned tuples from out
# check biosppy files for more info
out_heart_rate = out[6].tolist() # using numpy, convert ndarry into a list
stdev = np.std(out_heart_rate)
output.write(str(stdev) + ', ')
def getHeartRateAvg(task,index,output,samp_rate):
vals = []
# making sure we are able to get values whether or not they are in a
# two-dimensional array
for i in range(len(task)):
try:
vals.append(task[i][index])
except:
vals.append(task[i])
vals = filter(lambda x:x !="", vals) # remove empty strings
# extract heartrate and rpeak features using biosppy
# vals is raw ECG data
out = ecg.ecg(signal=vals, sampling_rate=samp_rate, show=False)
# indexed numbers correspond to the returned tuples from out
# check biosppy files for more info
out_heart_rate = out[3].tolist() # using numpy, convert ndarry into a list
average = str(int(sum(out_heart_rate)) / len(out_heart_rate))
output.write(average + ', ')
####HO A DISPOSIZIONE 5 ESEMPI DI ECG (ecg1, ecg2, ecg3, ecg4, ecg5)
with open('ecg1.csv') as csvfile:
readCSV = csv.reader(csvfile, delimiter=',')
tempo=list()
ecgdata=list()
for row in readCSV:
tempo.append(float(row[0]))
ecgdata.append(float(row[1]))
T=tempo[2]-tempo[1] #periodo di campionamento
fs=1/T #frequenza di campionamento
ecg_out = ecg.ecg(ecgdata, fs, show=False)
#distanza temporale tra picchi R, calcolo il tempo in cui si verificano il primo e il secondo picco
t1=tempo[ecg_out['rpeaks'][0]]
t2=tempo[ecg_out['rpeaks'][1]]
#calcolo delta T
deltaT0=(t2-t1)/20 #valore convenzionale
deltaIndice=int(deltaT0/T) #numero di celle di cui mi devo spostare
#calcolo K per picco T
K0 = (t2-t1)*0.6 #valore convenzionale dell'intervallo di tempo
K = int(K0/T) #numero effettivo di celle di cui mi devo spostare
from biosppy.signals import ecg
import csv
import scipy
with open('samples.csv') as csvfile: #apro file csv contenente i campioni del segnale presi da physionet
readCSV = csv.reader(csvfile, delimiter=',')
ecg_samples = list() #creo liste (ecg_ordinatae tempo_ascissa)
tempo = list()
for row in readCSV: # con un ciclo for richiamo tutti i valori contenuti nel file exel (samples)
tempo.append(float(row[0]))
ecg_samples.append(float(row[1]))
#calcolo frequenza campionamento che mi serve nella funzione out (già implementate)
Tc = tempo[2]-tempo[1]
fc = 1/Tc
out = ecg.ecg(signal=ecg_samples, sampling_rate= fc, show=True) # identifico picchi R
# In[ ]:
# In[ ]:
import numpy as np
# BioSPPy has the following dependencies
#import bidict, h5py, matplotlib, numpy, scikit-learn, scipy, shortuuid
from biosppy.signals import ecg
""" >>>>>>>> LOAD DATA <<<<<<<<< """
# load raw ECG signal
# ----------------------
# EXAMPLE:
#signal = np.loadtxt('./examples/ecg.txt')
# ----------------------
# Teresa ECG 2016/12/28
signal = np.loadtxt('C:\Users\Hugo\Dropbox\Projects\Neotilt\Code\Data\opensignals_98D3318047D6_2015-12-28_21-47-05.txt', usecols=[7])
""" >>>>>>>> PROCESS AND PLOT <<<<<<<<< """
# process it and plot
out = ecg.ecg(signal=signal, sampling_rate=1000, show=True)
