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)