def test_1b(self):
sig, fields = wfdb.srdsamp('sampledata/a103l',
sampfrom=12500, sampto=40000, channels=[2, 0])
siground = np.round(sig, decimals=8)
targetsig = np.genfromtxt('tests/targetoutputdata/target1b')
# Compare data streaming from physiobank
pbsig, pbfields = wfdb.srdsamp('a103l', pbdir = 'challenge/2015/training',
sampfrom=12500, sampto=40000, channels=[2, 0])
assert np.array_equal(siground, targetsig)
assert np.array_equal(sig, pbsig) and fields == pbfields
def test_2a(self):
sig, fields = wfdb.srdsamp('sampledata/100')
siground = np.round(sig, decimals=8)
targetsig = np.genfromtxt('tests/targetoutputdata/target2a')
# Compare data streaming from physiobank
pbsig, pbfields = wfdb.srdsamp('100', pbdir = 'mitdb')
# This comment line was manually added and is not present in the original physiobank record
del(fields['comments'][0])
assert np.array_equal(siground, targetsig)
assert np.array_equal(sig, pbsig) and fields == pbfields
def test_10(self):
sig, fields = wfdb.srdsamp('sampledata/03700181',
channels=[0, 2], sampfrom=1000, sampto=16000)
siground = np.round(sig, decimals=8)
targetsig = np.genfromtxt('tests/targetoutputdata/target10')
# Compare data streaming from physiobank
pbsig, pbfields = wfdb.srdsamp('03700181', pbdir = 'mimicdb/037',
channels=[0, 2], sampfrom=1000, sampto=16000)
assert np.array_equal(siground, targetsig)
assert np.array_equal(sig, pbsig) and fields == pbfields
def test_3b(self):
sig, fields = wfdb.srdsamp('sampledata/s0010_re', sampfrom=5000,
sampto=38000, channels=[13, 0, 4, 8, 3])
siground = np.round(sig, decimals=8)
targetsig = np.genfromtxt('tests/targetoutputdata/target3b')
# Compare data streaming from physiobank
pbsig, pbfields = wfdb.srdsamp('s0010_re', sampfrom=5000, pbdir = 'ptbdb/patient001',
sampto=38000, channels=[13, 0, 4, 8, 3])
assert np.array_equal(siground, targetsig)
assert np.array_equal(sig, pbsig) and fields == pbfields
def test_1d(self):
sig, fields = wfdb.srdsamp('sampledata/3000003_0003',
sampfrom=125, sampto=1000, channels=[1])
siground = np.round(sig, decimals=8)
targetsig = np.genfromtxt('tests/targetoutputdata/target1d')
targetsig = targetsig.reshape(len(targetsig), 1)
# Compare data streaming from physiobank
pbsig, pbfields = wfdb.srdsamp('3000003_0003', pbdir = 'mimic2wdb/30/3000003/',
sampfrom=125, sampto=1000, channels=[1])
assert np.array_equal(siground, targetsig)
assert np.array_equal(sig, pbsig) and fields == pbfields
def downloadWFDB(onda, carpeta, sdb, ondaName):
signalII = None
try:
sig, fields = wfdb.srdsamp(onda,
pbdir='mimic2wdb/matched/' + carpeta,
sampto=1)
channel = fields['signame'].index("II")
if (channel != None):
sig, fields = wfdb.srdsamp(onda,
pbdir='mimic2wdb/matched/' + carpeta,
channels=[channel])
print("downloaded:" + ondaName)
uploadToSDB(sig[:, 0], ondaName, sdb)
except ValueError:
print(ondaName + " no contains Signal II")
return
def generateCSVPerFile(filename):
if (re.search('\.dat', filename) != None):
fileBasename = os.path.splitext(filename)[0]
print("fileBasename = ", fileBasename)
try:
sig, fields = wfdb.srdsamp(fileBasename)
except ValueError:
print("ValueError occurred for fieBasename ", fileBasename)
return
numChannels = len(fields['signame'])
for chIndex in range(numChannels):
channelName = fields['signame'][chIndex]
perChannelFilename = '.'.join([fileBasename, channelName, 'csv'])
print("perChannelFilename=", perChannelFilename)
numSamples = fields['fs'] * 3600
fileHandle = open(perChannelFilename, 'w')
for chIndex in range(numChannels):
for i in range(numSamples):
timeStamp = i * fields['fs']
fileHandle.write(','.join(
[str(timeStamp), str(sig[i, chIndex])]))
fileHandle.write('\n')
fileHandle.close()
return
def preprocess(count = 30):
print("Preprocessing")
sig, fields = wfdb.srdsamp('data/mitdb/100')
ecg = sig[:500000,0]
diff = np.diff(ecg)
emax = np.max(ecg)
emin = np.min(ecg)
count = count - 2
bins = [ emin + (emax - emin)/count * i for i in range(count+1) ]
quantized = np.digitize(ecg, bins)
dequant = np.empty(len(quantized))
# dmax = np.max(diff)-0.01
# dmin = np.min(diff)+0.01
# count = count - 2
# print(dmin,dmax)
# bins = [ dmin + (dmax - dmin)/count * i for i in range(count+1) ]
# print("bins",len(bins))
# quantized = np.digitize(diff, bins)
#
# dequant = np.empty(len(quantized))
running = 0
for i in range(len(dequant)):
v = quantized[i]
running += bins[v-1]
dequant[i] = running
return ecg,quantized,dequant,bins
def generateCSVPerFile(filename):
if (re.search('\.dat', filename) != None):
fileBasename = os.path.splitext(filename)[0]
print("fileBasename = ", fileBasename)
try:
sig, fields = wfdb.srdsamp(fileBasename)
except ValueError:
print("ValueError occurred for fieBasename ", fileBasename)
return
numChannels = len(fields['signame'])
numSamples = fields['fs'] * 3600
allChannelsDF = pd.DataFrame(data=sig[:, :], columns=fields['signame'])
print(allChannelsDF.shape)
# for i in range(20):
# allChannelsDF = allChannelsDF.add(other = sig[i, :])
print(allChannelsDF.head())
# for chIndex in range(numChannels):
# channelName = fields['signame'][chIndex]
# perChannelFilename = '.'.join([fileBasename, channelName, 'csv'])
# print ("perChannelFilename=", perChannelFilename)
#
# fileHandle = open(perChannelFilename, 'w')
# for chIndex in range(numChannels):
# for i in range(numSamples):
# timeStamp = i * fields['fs']
# fileHandle.write(','.join([str(timeStamp), str(sig[i, chIndex])]))
# fileHandle.write('\n')
# fileHandle.close()
return
def classify_alarm(data_path, ann_path, sample_name, ecg_ann_type, verbose=False):
sig, fields = wfdb.srdsamp(data_path + sample_name)
is_regular = is_sample_regular(data_path, ann_path, sample_name, ecg_ann_type)
if is_regular:
return False
alarm_type = sample_name[0]
if alarm_type == "a":
arrhythmia_test = test_asystole
elif alarm_type == "b":
arrhythmia_test = test_bradycardia
elif alarm_type == "t":
arrhythmia_test = test_tachycardia
elif alarm_type == "v":
arrhythmia_test = test_ventricular_tachycardia
elif alarm_type == "f":
arrhythmia_test = test_ventricular_flutter_fibrillation
else:
raise Exception("Unknown arrhythmia alarm type")
# try:
return arrhythmia_test(data_path, ann_path, sample_name, ecg_ann_type, verbose)
def run_one_sample():
# sample_name = "v100s" # false alarm
# sample_name = "v141l" # noisy at beginning
# sample_name = "v159l" # quite clean
# sample_name = "v206s" # high baseline
# sample_name = "v143l"
# sample_name = "v696s"
sample_name = "v837l"
metric = "min"
channel_index = 0
ann_fs = 250.
ann_type = 'gqrs' + str(channel_index)
sig, fields = wfdb.srdsamp(data_path + sample_name)
channel_sig = sig[:, channel_index]
vtach_beats, nonvtach_beats = ventricular_beat_annotations_dtw(
channel_sig, ann_path, sample_name, metric, start_time, end_time,
ann_type)
plt.figure(figsize=[8, 5])
plt.plot(channel_sig[int(start_time * 250.):int(end_time * 250.)], 'b-')
plt.plot([int(index - 250. * start_time) for index in nonvtach_beats],
[channel_sig[int(index)] for index in nonvtach_beats],
'bo',
markersize=8)
plt.plot([int(index - 250. * start_time) for index in vtach_beats],
[channel_sig[int(index)] for index in vtach_beats],
'ro',
markersize=8)
plt.show()
def test_asystole(data_path, ann_path, sample_name, ecg_ann_type, verbose=False):
sig, fields = wfdb.srdsamp(data_path + sample_name)
channels = fields['signame']
fs = fields['fs']
# Start and end given in seconds
start, end, alarm_duration = get_start_and_end(fields)
current_start = start
current_end = current_start + parameters.ASYSTOLE_WINDOW_SIZE
max_score = 0
while current_end < end:
start_index, end_index = int(current_start*fs), int(current_end*fs)
subsig = sig[start_index:end_index,:]
summed_asystole_score = calc_summed_asystole_score(ann_path, sample_name, subsig, channels, ecg_ann_type,
current_start, current_end, verbose)
max_score = max(max_score, summed_asystole_score)
current_start += parameters.ASYSTOLE_ROLLING_INCREMENT
current_end = current_start + parameters.ASYSTOLE_WINDOW_SIZE
if verbose:
print(sample_name + " has max asystole score: " + str(max_score))
return max_score > 0
def calculateFourierTransform(filename):
if (re.search('\.dat', filename) != None):
fileBasename = os.path.splitext(filename)[0]
print("fileBasename = ", fileBasename)
try:
sig, fields = wfdb.srdsamp(fileBasename)
except ValueError:
print("ValueError occurred for fieBasename ", fileBasename)
return
numChannels = len(fields['signame'])
numSamples = fields['fs'] * 3600
# fields['fs'] contains the frequency
numSamplesPerEpoch = int(fields['fs'] * 1000 / epochLength)
allChannelsDF = pd.DataFrame(data=sig[:, :], columns=fields['signame'])
llDf = pd.DataFrame(columns=fields['signame'])
print(allChannelsDF.shape)
# for i in range(20):
# allChannelsDF = allChannelsDF.add(other = sig[i, :])
print(allChannelsDF.head())
for i in range(10):
llDf = llDf.append(allChannelsDF.iloc[i] -
allChannelsDF.iloc[i + 1],
ignore_index=True)
print(llDf.head())
return
def readData(filename):
global annotationArray
global signalArray
#read in data using
record = wfdb.rdsamp(filename, sampto=sampSize)
annotation = wfdb.rdann(filename, 'atr', sampto=sampSize)
sig, fields = wfdb.srdsamp(filename, sampto=sampSize)
#read record and signal into an array
for i in range(0, len(sig)):
signalArray = np.append(
signalArray,
np.array([[float("{0:.3f}".format(i * sampIncrement)),
sig[i][0]]]),
axis=0)
#read annotations into array
for i in range(0, len(annotation.annsamp)):
annotationArray = np.append(
annotationArray,
np.array([[
annotation.annsamp[i],
float("{0:.3f}".format(annotation.annsamp[i] / 360)),
float("{0:.3f}".format(signalArray[:,
1][annotation.annsamp[i]])),
annotation.anntype[i]
]]),
axis=0)
def readData(filename):
global annotationArray
global signalArray
#read in data using
'''
record = wfdb.rdsamp(filename, sampto = sampSize)
annotation = wfdb.rdann(filename, 'atr', sampto = sampSize)
sig, fields = wfdb.srdsamp(filename, sampto = sampSize)
'''
record = wfdb.rdsamp(filename)
annotation = wfdb.rdann(filename, 'atr')
sig, fields = wfdb.srdsamp(filename)
print("\nReading in ",
len(sig) / 300, "seconds of data from file", filename)
for i in range(0, len(sig)):
if (i % 100 == 0):
sys.stdout.write("\rReading Data ... {0:.2f}%".format(
(float(i) / len(sig)) * 100))
sys.stdout.flush()
signalArray.append(sig[i])
sys.stdout.write("\rReading Data ... complete!")
sys.stdout.flush()
for i in range(1, len(annotation.annsamp)):
annotationArray.append([annotation.annsamp[i], annotation.anntype[i]])
def generate_training(filename):
training = []
with open(filename, 'r') as f:
reader = csv.DictReader(f)
for row in reader:
sample_name = row['sample_name']
is_true_beat = int(row['is_vtach']) == 1
start_time = float(row['start_time'])
end_time = float(row['end_time'])
# peak_time = float(row['peak_time'])
# start_time = peak_time - AVERAGE_START_DIFF
# end_time = peak_time + AVERAGE_END_DIFF
sig, fields = wfdb.srdsamp(data_path + sample_name)
start_index = int(start_time * 250.)
end_index = int(end_time * 250.)
channel_index = fields['signame'].index(row['lead'])
beat_sig = sig[start_index:end_index, channel_index]
training.append((beat_sig, is_true_beat, sample_name))
return training
def download_word(wave):
"""downloads the word, after searching it in the mimic data base.
word -- the word that represents the wave
"""
print(wave['word'], wave['from'], wave['to'], wave['record'])
onda = wave['record'].split("/")[3]
pbdir = wave['record'].replace("/" + onda, '')
if 'mimic3wdb' in wave['record']:
pbdir = onda.split("-")[0].replace("s", '').zfill(6)
onda = onda.replace(onda.split("-")[0].replace("s", ''), pbdir)
pbdir = (wave['record'].split("/")[0] + '/' +
wave['record'].split("/")[1] + '/p' + pbdir[:2] + '/p' +
pbdir + '/')
onda = onda.replace('s', 'p')
_, fields = wfdb.srdsamp(onda, pbdir=pbdir, sampto=1)
signal_ii = fields['signame'].index("II")
sfrom = wave['from'] - 20
sto = wave['to']
original = wfdb.rdsamp(onda,
pbdir=pbdir,
channels=[signal_ii],
sampfrom=sfrom,
sampto=sto).p_signals
original = original[~np.isnan(original)]
save_word(original, wave['word'])
return original
def __init__(self, num_training_cases, dim):
# Import data from dataset 14172
signals, fields = wfdb.srdsamp('../data/14172', channels=[0, 1])
# print(self.signals)
# display(self.fields)
self.annotation = wfdb.rdann(
'../data/14172',
'atr') # Import annotations from the same data set
peaks = self.annotation.annsamp # Let's find the self.peaks of each ECG where the annotations are
signals = np.matrix.transpose(signals)
# Don't take into account border self.peaks in case they are interrupted
peaks[-1] = 0
peaks[-2] = 0
peaks[0] = 0
peaks[1] = 0
self.size_hb = 125 # Size of heartbeat
self.num_hb = sum(peaks > self.size_hb) # Count number of annotations
self.heartbeats = np.zeros([self.num_hb, 2 * self.size_hb
]) # Save space for the data matrix
idx_hb = 0 # Initialize the index for each peak
for i in peaks:
if i > self.size_hb: # just in case the first heartbeat is truncated
self.heartbeats[idx_hb] = signals[0][
i - self.size_hb:i +
self.size_hb] # take all samples from left and right of i
idx_hb += 1
self.heartbeats = np.transpose(self.heartbeats)
self.num_hb = self.heartbeats.shape[1]
print('Number of Heartbeats: ', self.num_hb)
self.heartbeats = self.calculate_means(
) # Delete the mean from the data.
self.print_kinds() # View the kinds of hearbeats
self.classes = self.calculate_classes(
) # Get the kind of each heartbeat (N, V, S, J or others)
[
self.heartbeatsN, self.heartbeatsV, self.heartbeatsS,
self.heartbeatsJ
] = self.classify() # get idx by class
self.filter_data(dim=dim)
[
self.heartbeatsN, self.heartbeatsV, self.heartbeatsS,
self.heartbeatsJ
] = self.classify()
# Training Set
self.num_training_cases = num_training_cases # set number of training cases
[self.trainN, self.trainV, self.trainS,
self.trainJ] = self.generate_training_cases()
self.training_classes = [
i for i in range(0, 4) for _ in range(0, self.num_training_cases)
]
self.training_set = np.concatenate(
(self.trainN, self.trainV, self.trainS, self.trainJ), axis=1)
self.training_set = np.transpose(self.training_set)
def test_ventricular_flutter_fibrillation(data_path,
ann_path,
sample_name,
ecg_ann_type,
verbose=False,
fs=parameters.DEFAULT_ECG_FS,
ann_fs=parameters.DEFAULT_ECG_FS,
std_threshold=parameters.VFIB_ABP_THRESHOLD,
window_size=parameters.VFIB_WINDOW_SIZE,
rolling_increment=parameters.VFIB_ROLLING_INCREMENT):
sig, fields = wfdb.srdsamp(data_path + sample_name)
channels = fields['signame']
# Start and end given in seconds
start, end, alarm_duration = get_start_and_end(fields)
alarm_sig = sig[int(start*fs):int(end*fs),:]
ecg_channels = get_channels_of_type(channels, "ECG")
abp_channels = get_channels_of_type(channels, "BP")
# Find max duration of low frequency signal from all channels
dlfmax = 0
for channel_index in ecg_channels:
channel_index = int(channel_index)
channel_dlfmax = calculate_dlfmax(alarm_sig[:,channel_index])
dlfmax = max(dlfmax, channel_dlfmax)
# Initialize R vector to a value based on the D_lfmax (duration of low frequency)
if dlfmax > parameters.VFIB_DLFMAX_LIMIT:
r_vector_value = 1.
else:
r_vector_value = 0.
size = int((alarm_duration - window_size) / rolling_increment) + 1
r_vector = [r_vector_value] * size
# Adjust R vector based on whether standard deviation of ABP channel is > or < the threshold
for channel_index in abp_channels:
r_delta = get_abp_std_scores(alarm_sig[:,int(channel_index)], std_threshold, window_size, rolling_increment)
r_vector = r_vector + r_delta
# Adjust R vector based on dominant frequency in signal
for channel_index in ecg_channels:
channel_index = int(channel_index)
dominant_freqs = get_dominant_freq_array(alarm_sig[:,channel_index])
regular_activity = get_regular_activity_array(alarm_sig, fields, ann_path, sample_name, ecg_ann_type)
adjusted_dominant_freqs = adjust_dominant_freqs(dominant_freqs, regular_activity)
new_r_vector = np.array([])
for dominant_freq, r_value in zip(adjusted_dominant_freqs, r_vector):
if dominant_freq < parameters.VFIB_DOMINANT_FREQ_THRESHOLD:
new_r_vector = np.append(new_r_vector, 0.)
else:
new_r_vector = np.append(new_r_vector, r_value)
r_vector = new_r_vector
return any([ r_value > 0 for r_value in r_vector ])
def test_3(self):
sig, _ = wfdb.srdsamp('sampledata/100')
lb = -5
ub = 15
x = wfdb.processing.normalize(sig[:, 0], lb, ub)
assert x.shape[0] == sig.shape[0]
assert numpy.min(x) >= lb
assert numpy.max(x) <= ub
def get_full_ecg(filenumber, base_filename="mit_bih/"):
max_length = 430
annotation = wfdb.rdann(base_filename+str(filenumber), 'atr', sampto=650000)
ecg_signal, _ = wfdb.srdsamp(base_filename+str(filenumber))
ecg_lead_1 = ecg_signal[:,0]
ecg_lead_2 = ecg_signal[:,1]
unique_labels_df = annotation.get_contained_labels(inplace=False)
annotation_indices = annotation.sample
annotation_classes = annotation.symbol
sampling_frequency = annotation.fs
for index,beat_class in enumerate(annotation_classes):
if beat_class not in beat_dict:
np.delete(annotation_indices, index)
np.delete(annotation_classes, index)
complete_beats = []
beat_indexes = []
for index,current_beat in enumerate(annotation_indices):
if index > 0 and index<len(annotation_indices)-1:
beat_before = annotation_indices[index-1]
beat_after = annotation_indices[index+1]
start_recording = ((current_beat-beat_before)//2) + beat_before
end_recording = ((beat_after-current_beat)//2)+current_beat
complete_beat_1 = ecg_lead_1[start_recording:end_recording]
complete_beat_2 = ecg_lead_2[start_recording:end_recording]
if "st_petersburg" in base_filename and downsample_to_match_incart != 1:
complete_beat_1 = signal.resample(complete_beat_1,int(round(len(complete_beat_1)*1.401)))
complete_beat_2 = signal.resample(complete_beat_2,int(round(len(complete_beat_2)*1.401)))
elif downsample_to_match_incart == 1:
complete_beat_1 = signal.resample(complete_beat_1,257)
complete_beat_2 = signal.resample(complete_beat_2,257)
if len(complete_beat_1) <= max_length:
complete_beat_1 = np.pad(complete_beat_1, (0, max_length - len(complete_beat_1)), 'constant')
complete_beat_2 = np.pad(complete_beat_2, (0, max_length - len(complete_beat_2)), 'constant')
complete_beat = np.append(complete_beat_1, complete_beat_2)
#print(complete_beat)
beat_label = annotation_classes[index]
#beat_indexes.append([start_recording,end_recording,beat_label])
this_index = current_beat - start_recording
beat_indexes.append(this_index)
complete_beats.append([complete_beat,beat_label])
return complete_beats, beat_indexes
def filtrar_ler(f):
# read signal
sig, fields = wfdb.srdsamp(f, channels=[0])
allrecord = wfdb.rdsamp(f, channels=[0], physical=False)
# time discrete signal -> numpy array
xall = allrecord.d_signals[:, 0]
# freq at which the signal is sampled
fs = fields['fs']
print("frequencia = " + str(fs))
return xall, fs
def is_sample_regular(data_path,
ann_path,
sample_name,
ecg_ann_type,
start=None,
end=None,
verbose=False):
sig, fields = wfdb.srdsamp(data_path + sample_name)
channels = fields['signame']
nonresp_channels = [ channels.index(channel) for channel in channels if channel != "RESP" ]
if start is None or end is None:
start, end, alarm_duration = get_start_and_end(fields)
else:
alarm_duration = end - start
# try:
# invalids = {}
# for channel_index in nonresp_channels:
# channel = channels[channel_index]
# with open(ann_path + sample_name + "-invalids.csv", "r") as f:
# reader = csv.reader(f)
# channel_invalids = [ int(float(row[channel_index])) for row in reader]
# invalids[channel] = channel_invalids[start*250:end*250]
# except Exception as e:
# print("Error finding invalids for sample " + sample_name, e)
# invalids = calculate_invalids_sig(sig, fields, start, end)
invalids = calculate_invalids_sig(sig, fields, start, end)
for channel_index in range(len(channels)):
channel = channels[channel_index]
channel_type = get_channel_type(channel)
# Ignore respiratory channel
if channel_type == "Resp":
continue
alarm_prefix = sample_name[0]
# Only use ECG channels for ventricular fib
if alarm_prefix == "f":
if channel_type != "ECG":
continue
rr = get_channel_rr_intervals(ann_path, sample_name, channel_index, fields, ecg_ann_type)
is_regular = check_interval_regular_activity(rr, invalids, alarm_duration, channel)
# If any channel exhibits regular activity, deem signal as regular activity
if is_regular:
return True
return False
def loadAllData(sigType="MLII", directory="mitdb"):
signalType = sigType
for file in os.listdir(directory):
if file.endswith(".dat"):
sig, fields = wfdb.srdsamp(directory + "/" +
os.path.splitext(file)[0])
if (fields['signame'][0] == signalType):
signalIndex = 0
elif (fields['signame'][1] == signalType):
signalIndex = 1
readData(directory + '/' + os.path.splitext(file)[0])
print("\nTotal signals ", len(signalArray))
def test_1(self):
sig, fields = wfdb.srdsamp('sampledata/100')
ann = wfdb.rdann('sampledata/100', 'atr')
fs = fields['fs']
fs_target = 50
new_sig, new_ann = wfdb.processing.resample_singlechan(sig[:, 0], ann, fs, fs_target)
expected_length = int(sig.shape[0]*fs_target/fs)
assert new_sig.shape[0] == expected_length
def get_full_ecg(filenumber,
base_filename="external_original/mit_bih_normal/"):
max_length = 1300
annotation = wfdb.rdann(base_filename + str(filenumber),
'atr',
sampto=650000)
ecg_signal, _ = wfdb.srdsamp(base_filename + str(filenumber))
ecg_lead_1 = ecg_signal[:, 0]
ecg_lead_2 = ecg_signal[:, 1]
unique_labels_df = annotation.get_contained_labels(inplace=False)
annotation_indices = annotation.sample
annotation_classes = annotation.symbol
sampling_frequency = annotation.fs
for index, beat_class in enumerate(annotation_classes):
if str(beat_class) not in beat_dict:
np.delete(annotation_indices, index)
np.delete(annotation_classes, index)
complete_beats = []
beat_indexes = []
for index, current_beat in enumerate(annotation_indices):
if index > 0 and index < len(annotation_indices) - 1:
beat_before = annotation_indices[index - 1]
beat_after = annotation_indices[index + 1]
start_recording = ((current_beat - beat_before) // 2) + beat_before
end_recording = ((beat_after - current_beat) // 2) + current_beat
complete_beat_1 = ecg_lead_1[start_recording:end_recording]
complete_beat_1 = np.pad(complete_beat_1,
(0, max_length - len(complete_beat_1)),
'constant')
complete_beat_2 = ecg_lead_2[start_recording:end_recording]
complete_beat_2 = np.pad(complete_beat_2,
(0, max_length - len(complete_beat_2)),
'constant')
complete_beat = np.append(complete_beat_1, complete_beat_2)
#print(complete_beat)
beat_label = annotation_classes[index]
beat_indexes.append([start_recording, end_recording, beat_label])
complete_beats.append([complete_beat, beat_label])
return complete_beats
def test_4c(self):
sig, fields = wfdb.srdsamp('sampledata/03700181',
channels=[0, 2], sampfrom=1000, sampto=16000)
siground = np.round(sig, decimals=8)
targetsig = np.genfromtxt('tests/targetoutputdata/target4c')
# Compare data streaming from physiobank
pbsig, pbfields = wfdb.srdsamp('03700181', pbdir = 'mimicdb/037',
channels=[0, 2], sampfrom=1000, sampto=16000)
# Test file writing. Multiple samples per frame and skew.
# Have to read all the samples in the record, ignoring skew
recordnoskew = wfdb.rdsamp('sampledata/03700181', physical=False,
smoothframes=False, ignoreskew=True)
recordnoskew.wrsamp(expanded=True)
# Read the written record
writesig, writefields = wfdb.srdsamp('03700181', channels=[0, 2],
sampfrom=1000, sampto=16000)
assert np.array_equal(siground, targetsig)
assert np.array_equal(sig, pbsig) and fields == pbfields
assert np.array_equal(sig, writesig) and fields == writefields
def loadPhysionetMetadata(
src,
recordPrefix=BASE_ctu_uhb_ctgdb,
selectedFields=['pH', 'BDecf', 'pCO2', 'BE', 'Apgar1', 'Apgar5']):
recordName = recordPrefix + '/' + src
# ctgRecord = wfdb.rdsamp(fname)
sig, fields = wfdb.srdsamp(recordName)
meta = {}
for entry in fields['comments']:
tokens = entry.split()
if tokens[0] in selectedFields:
meta[tokens[0]] = parseToken(tokens[1])
return meta
def read_signals(data_path):
signals_dict = {}
fields_dict = {}
for filename in os.listdir(data_path):
if filename.endswith(HEADER_EXTENSION):
sample_name = filename.rstrip(HEADER_EXTENSION)
sig, fields = wfdb.srdsamp(data_path + sample_name)
signals_dict[sample_name] = sig
fields_dict[sample_name] = fields
return signals_dict, fields_dict
def test_bradycardia(data_path, ann_path, sample_name, ecg_ann_type, verbose=False):
sig, fields = wfdb.srdsamp(data_path + sample_name)
channels = fields['signame']
# Start and end given in seconds
start, end, alarm_duration = get_start_and_end(fields)
rr_intervals_list = get_rr_intervals_list(ann_path, sample_name, ecg_ann_type, fields, start, end)
best_channel_rr = find_best_channel(rr_intervals_list, alarm_duration)
min_hr = get_min_hr(best_channel_rr, parameters.BRADYCARDIA_NUM_BEATS)
if verbose:
print(sample_name + " with min HR: " + str(min_hr))
return min_hr < parameters.BRADYCARDIA_HR_MIN
def test_ventricular_tachycardia(data_path,
ann_path,
sample_name,
ecg_ann_type,
verbose=False,
fs=parameters.DEFAULT_ECG_FS,
order=parameters.ORDER,
num_beats=parameters.VTACH_NUM_BEATS,
std_threshold=parameters.VTACH_ABP_THRESHOLD,
window_size=parameters.VTACH_WINDOW_SIZE,
rolling_increment=parameters.VTACH_ROLLING_INCREMENT):
sig, fields = wfdb.srdsamp(data_path + sample_name)
channels = fields['signame']
# Start and end given in seconds
start_time, end_time, alarm_duration = get_start_and_end(fields)
alarm_sig = sig[int(start_time*fs):int(end_time*fs),:]
ecg_channels = get_channels_of_type(channels, "ECG")
abp_channels = get_channels_of_type(channels, "BP")
# Initialize R vector
size = int((alarm_duration - window_size) / rolling_increment) + 1
r_vector = [0.] * size
# index = int(channels.index("II"))
# ann_type = get_ann_type("II", index, ecg_ann_type)
# r_delta = get_ventricular_beats_scores(alarm_sig[:,int(index)], ann_path, sample_name, ann_type, start_time, end_time, "II")
# r_vector = r_vector + r_delta
# Adjust R vector based on ventricular beats in signal
for channel_index in ecg_channels:
index = int(channel_index)
channel_name = channels[index]
ann_type = get_ann_type(channel_name, index, ecg_ann_type)
r_delta = get_ventricular_beats_scores(alarm_sig[:,int(index)], ann_path, sample_name, ann_type, start_time, end_time, channel_name)
r_vector = r_vector + r_delta
# if verbose:
# channel_sig = alarm_sig[:,index]
# lf, sub = get_lf_sub(channel_sig, order)
# ventricular_beats = ventricular_beat_annotations(lf, sub, ann_path + sample_name, ann_type, start_time, end_time, verbose)
# max_hr = max_ventricular_hr(ventricular_beats, num_beats, fs)
# print(str(sample_name) + " on channel " + str(channels[int(channel_index)]) + " with max ventricular HR: ", str(max_hr))
return any([ r_value > 0 for r_value in r_vector ])
def test_7(self):
sig, fields = wfdb.srdsamp('sampledata/100', channels = [0, 1])
ann = wfdb.rdann('sampledata/100', 'atr')
fs = fields['fs']
min_bpm = 10
max_bpm = 350
min_gap = fs*60/min_bpm
max_gap = fs*60/max_bpm
y_idxs = wfdb.processing.correct_peaks(sig[:,0], ann.annsamp, min_gap, max_gap, smooth_window=150)
yz = numpy.zeros(sig.shape[0])
yz[y_idxs] = 1
yz = numpy.where(yz[:10000]==1)[0]
assert numpy.array_equal(yz, [77, 370, 663, 947, 1231, 1515, 1809, 2045, 2403, 2706, 2998, 3283, 3560, 3863, 4171, 4466, 4765, 5061, 5347, 5634, 5919, 6215, 6527, 6824, 7106, 7393, 7670, 7953, 8246, 8539, 8837, 9142, 9432, 9710, 9998])
def preprocess(decimation = 8):
print("Preprocessing")
sig, fields = wfdb.srdsamp('data/mitdb/100')
# ecg = sig[:500000,0]
ecg = sig[:,0]
from scipy import signal
# eorig = signal.resample(eorig, len(eorig))
if decimation != 0:
ecg = signal.decimate(ecg, decimation, ftype='fir')
diff = np.diff(ecg)
cum = 0
filtered = np.empty_like(ecg)
for i in range(len(diff)):
cum *= 0.9
cum += diff[i]
filtered[i] = cum
return ecg[:-1],diff,filtered[:-1]
def test_2e(self):
sig, fields = wfdb.srdsamp('sampledata/311derive', sampfrom=1, sampto=978)
sig = np.round(sig, decimals=8)
targetsig = np.genfromtxt('tests/targetoutputdata/target2e')
targetsig = targetsig.reshape([977, 1])
assert np.array_equal(sig, targetsig)
