def __init__(self, foldername="EEGMA/", filter_order=2, lbf=10, ubf=20,
sampling_rate=500, download=False, download_colab=False):
# super.__init__(self)
self.fields = []
self.rows = []
if download:
print("Downloading...")
self.download(download=download_colab)
with open(foldername + "subject-info.csv", 'r') as csvfile:
csvreader = csv.reader(csvfile)
self.fields = next(csvreader)
for row in csvreader:
self.rows.append(row)
self.X = list()
self.Y = list()
for i in range(35):
try:
signals, signal_headers, header = highlevel.read_edf(foldername + "Subject" + str(i) + "_2.edf")
except:
signals, signal_headers, header = highlevel.read_edf(foldername + "Subject0" + str(i) + "_2.edf")
nyq = sampling_rate/2
b, a = signal.butter(filter_order, [lbf/nyq, ubf/nyq], btype='band')
for k in range(21):
signals[k, :] = signal.lfilter(b, a, signals[k, :])
self.X.append(tf.reshape(signals, (1, 21, -1, 1)))
self.Y.append(self.Binary(np.ceil(float(self.rows[i][4]))))
self.X = tf.concat(self.X, 0)
self.Y = np.array(self.Y)
def test_blocksize_auto(self):
""" test that the blocksize parameter works as intended"""
file = '{}.edf'.format(self.tmp_testfile)
siglen = 256 * 155
signals = np.random.rand(10, siglen)
sheads = highlevel.make_signal_headers([str(x) for x in range(10)],
sample_frequency=256,
physical_max=1,
physical_min=-1)
valid_block_sizes = [-1, 1, 5, 31]
for block_size in valid_block_sizes:
highlevel.write_edf(file, signals, sheads, block_size=block_size)
signals2, _, _ = highlevel.read_edf(file)
np.testing.assert_allclose(signals, signals2, atol=0.01)
with self.assertRaises(AssertionError):
highlevel.write_edf(file, signals, sheads, block_size=61)
with self.assertRaises(AssertionError):
highlevel.write_edf(file, signals, sheads, block_size=-2)
# now test non-divisor block_size
siglen = signals.shape[-1]
highlevel.write_edf(file, signals, sheads, block_size=60)
signals2, _, _ = highlevel.read_edf(file)
self.assertEqual(signals2.shape, (10, 256 * 60 * 3))
np.testing.assert_allclose(signals2[:, :siglen], signals, atol=0.01)
np.testing.assert_allclose(signals2[:, siglen:],
np.zeros([10, 25 * 256]),
atol=0.0001)
def data_length(folder):
seizure_files = [
(str(seizure))
for seizure in sorted(Path(folder).glob('seizures/*.edf'))
]
normal_files = [(str(normal))
for normal in sorted(Path(folder).glob('normal/*.edf'))]
print("Number of files with seizures: " + str(len(seizure_files)))
print("Number of files without siezures: " + str(len(normal_files)))
signals, _, _ = highlevel.read_edf(str(seizure_files[20]))
print(signals[10])
length_seizures = []
length_normal = []
for seizure_file in seizure_files:
signals, _, _ = highlevel.read_edf(str(seizure_file))
length_seizures.append(len(signals[0]))
for normal_file in normal_files:
signals, _, _ = highlevel.read_edf(str(normal_file))
length_normal.append(len(signals[0]))
dis = np.sum(np.array(length_seizures)) # data in seizure
din = np.sum(np.array(length_normal)) # data in normal
print("Seizure: " + str(dis) + "fr/ " + str(dis / 256) + "s/ " +
str(dis / 256 / 3600) + "h")
print("Normal: " + str(din) + "fr/ " + str(din / 256) + "s/ " +
str(din / 256 / 3600) + "h")
# data_length("/home/jmsvanrijn/Documents/Afstuderen/Code/low-power-epilepsy-detection/data/processed/")
def test_read_write_edf(self):
startdate = datetime.now()
t = startdate
startdate = datetime(t.year, t.month, t.day, t.hour, t.minute,
t.second)
header = highlevel.make_header(technician='tech',
recording_additional='radd',
patientname='name',
patient_additional='padd',
patientcode='42',
equipment='eeg',
admincode='420',
gender='Male',
startdate=startdate,
birthdate='05.09.1980')
annotations = [[0.01, -1, 'begin'], [0.5, -1, 'middle'],
[10, -1, 'end']]
header['annotations'] = annotations
signal_headers1 = highlevel.make_signal_headers(
['ch' + str(i) for i in range(5)])
signals = np.random.rand(5, 256 * 300) * 200 #5 minutes of eeg
success = highlevel.write_edf(self.edfplus_data_file, signals,
signal_headers1, header)
self.assertTrue(os.path.isfile(self.edfplus_data_file))
self.assertGreater(os.path.getsize(self.edfplus_data_file), 0)
self.assertTrue(success)
signals2, signal_headers2, header2 = highlevel.read_edf(
self.edfplus_data_file)
self.assertEqual(len(signals2), 5)
self.assertEqual(len(signals2), len(signal_headers2))
for shead1, shead2 in zip(signal_headers1, signal_headers2):
self.assertDictEqual(shead1, shead2)
self.assertDictEqual(header, header2)
np.testing.assert_allclose(signals, signals2, atol=0.01)
signals = (signals * 100).astype(np.int8)
success = highlevel.write_edf(self.edfplus_data_file,
signals,
signal_headers1,
header,
digital=True)
self.assertTrue(os.path.isfile(self.edfplus_data_file))
self.assertGreater(os.path.getsize(self.edfplus_data_file), 0)
self.assertTrue(success)
signals2, signal_headers2, header2 = highlevel.read_edf(
self.edfplus_data_file, digital=True)
self.assertEqual(len(signals2), 5)
self.assertEqual(len(signals2), len(signal_headers2))
for shead1, shead2 in zip(signal_headers1, signal_headers2):
self.assertDictEqual(shead1, shead2)
self.assertDictEqual(header, header2)
np.testing.assert_array_equal(signals, signals2)
def test_drop_channel(self):
signal_headers = highlevel.make_signal_headers(
['ch' + str(i) for i in range(5)])
signals = np.random.rand(5, 256 * 300) * 200 #5 minutes of eeg
highlevel.write_edf(self.drop_from, signals, signal_headers)
dropped = highlevel.drop_channels(self.drop_from,
to_keep=['ch1', 'ch2'],
verbose=True)
signals2, signal_headers, header = highlevel.read_edf(dropped)
np.testing.assert_allclose(signals[1:3, :], signals2, atol=0.01)
highlevel.drop_channels(self.drop_from,
self.drop_from[:-4] + '2.edf',
to_drop=['ch0', 'ch1', 'ch2'])
signals2, signal_headers, header = highlevel.read_edf(
self.drop_from[:-4] + '2.edf')
np.testing.assert_allclose(signals[3:, :], signals2, atol=0.01)
with self.assertRaises(AssertionError):
highlevel.drop_channels(self.drop_from,
to_keep=['ch1'],
to_drop=['ch3'])
def test_fortran_write(self):
# Create Fortran contiguous array
signals = np.random.randint(-2048, 2048, [4, 5000000])
signals = np.asfortranarray(signals)
# Write
highlevel.write_edf_quick(self.edfplus_data_file,
signals.astype(np.int32),
sfreq=250,
digital=True)
# Read and check
signals2, _, _ = highlevel.read_edf(self.edfplus_data_file,
digital=True,
verbose=True)
np.testing.assert_allclose(signals, signals2)
# Create Fortran contiguous list
signals = [np.random.randint(-2048, 2048, (5000000, ))] * 4
# Write
highlevel.write_edf_quick(self.edfplus_data_file,
signals,
sfreq=250,
digital=True)
# Read and check
signals2, _, _ = highlevel.read_edf(self.edfplus_data_file,
digital=True,
verbose=True)
np.testing.assert_allclose(signals, signals2)
def test_read_write_with_annotations(self):
signals, signal_headers, header = highlevel.read_edf(self.test_generator)
expected = [[0.0, -1, 'Recording starts'], [600.0, -1, 'Recording ends']]
self.assertEqual(header['annotations'], expected)
highlevel.write_edf(self.edfplus_data_file, signals, signal_headers, header)
signals2, signal_header2s, header2 = highlevel.read_edf(self.edfplus_data_file)
self.assertEqual(header['annotations'], header2['annotations'])
def test_quick_write(self):
signals = np.random.randint(-2048, 2048, [3, 256*60])
highlevel.write_edf_quick(self.edfplus_data_file, signals.astype(np.int32), sfreq=256, digital=True)
signals2, _, _ = highlevel.read_edf(self.edfplus_data_file, digital=True)
np.testing.assert_allclose(signals, signals2)
signals = np.random.rand(3, 256*60)
highlevel.write_edf_quick(self.edfplus_data_file, signals, sfreq=256)
signals2, _, _ = highlevel.read_edf(self.edfplus_data_file)
np.testing.assert_allclose(signals, signals2, atol=0.00002)
def plotEdfs(edfFilename1, edfFilename2):
signals1, signalHeaders1, header1 = highlevel.read_edf(edfFilename1)
signals2, signalHeaders2, header2 = highlevel.read_edf(edfFilename2)
plt.plot(signals1[0], color="green")
plt.plot(signals2[0], "x", color="blue")
plt.show()
plt.plot(signals1[1], color="orange")
plt.plot(signals2[1], color="red")
plt.show()
def test_read_write_edf(self):
startdate = datetime.now()
t = startdate
startdate = datetime(t.year,t.month,t.day,t.hour, t.minute,t.second)
header = highlevel.make_header(technician='tech', recording_additional='r_add',
patientname='name', patient_additional='p_add',
patientcode='42', equipment='eeg', admincode='120',
gender='Male', startdate=startdate,birthdate='05.09.1980')
annotations = [[0.01, -1, 'begin'],[0.5, -1, 'middle'],[10, -1, 'end']]
signal_headers1 = highlevel.make_signal_headers(['ch'+str(i) for i in range(5)])
for file_type in [-1,0,1,2,3]:
if file_type in [0, 2]:
header['annotations'] = []
else:
header['annotations'] = annotations
file = '{}_{}_phys.edf'.format(self.tmp_testfile, file_type)
signals = np.random.rand(5, 256*300)*200 #5 minutes of eeg
success = highlevel.write_edf(file, signals, signal_headers1, header, file_type=file_type)
self.assertTrue(os.path.isfile(file))
self.assertGreater(os.path.getsize(file), 0)
self.assertTrue(success)
signals2, signal_headers2, header2 = highlevel.read_edf(file)
self.assertEqual(len(signals2), 5)
self.assertEqual(len(signals2), len(signal_headers2))
for shead1, shead2 in zip(signal_headers1, signal_headers2):
self.assertDictEqual(shead1, shead2)
np.testing.assert_allclose(signals, signals2, atol=0.01)
if file_type in [-1, 1, 3]:
self.assertDictEqual(header, header2)
file = '{}_{}_dig.edf'.format(self.tmp_testfile, file_type)
signals = (signals*100).astype(np.int8)
success = highlevel.write_edf(file, signals, signal_headers1, header, digital=True)
self.assertTrue(os.path.isfile(file))
self.assertGreater(os.path.getsize(file), 0)
self.assertTrue(success)
signals2, signal_headers2, header2 = highlevel.read_edf(file, digital=True)
self.assertEqual(len(signals2), 5)
self.assertEqual(len(signals2), len(signal_headers2))
np.testing.assert_array_equal(signals, signals2)
for shead1, shead2 in zip(signal_headers1, signal_headers2):
self.assertDictEqual(shead1, shead2)
# EDF/BDF header writing does not correctly work yet
if file_type in [-1, 1, 3]:
self.assertDictEqual(header, header2)
def test_dig2phys_calc(self):
signals_phys, shead, _ = highlevel.read_edf(self.test_generator)
signals_dig, _, _ = highlevel.read_edf(self.test_generator, digital=True)
dmin, dmax = shead[0]['digital_min'], shead[0]['digital_max']
pmin, pmax = shead[0]['physical_min'], shead[0]['physical_max']
# convert to physical
signal_phys2 = highlevel.dig2phys(signals_dig, dmin, dmax, pmin, pmax)
np.testing.assert_allclose(signals_phys, signal_phys2)
# convert to digital
signals_dig2 = highlevel.phys2dig(signals_phys, dmin, dmax, pmin, pmax)
signals_dig2 = np.rint(signals_dig2)
np.testing.assert_allclose(signals_dig, signals_dig2)
def get_data(pathname, filename):
"""reads data from files and returns dataframes for ecg and excel."""
signals, signal_headers, header = highlevel.read_edf(
os.path.join(pathname, filename))
start_date = header['startdate']
sample_rate = {
header['label']: header['sample_rate']
for header in signal_headers
}
ecg_timestamp = [
start_date +
datetime.timedelta(microseconds=1. / sample_rate['ECG'] * n * 1e6)
for n in range(len(signals[0]))
] # 0 is index of ECG
acc_timestamp = [
start_date + datetime.timedelta(
microseconds=1. / sample_rate['Accelerometer_X'] * n * 1e6)
for n in range(len(signals[1]))
] # 1 is index of Accel_X
ecg = pd.DataFrame(signals[0], index=ecg_timestamp, columns=['ECG'])
acc = pd.DataFrame(
np.transpose(signals[1:4]),
index=acc_timestamp,
columns=[header['label'] for header in signal_headers[1:4]])
acc['mag'] = np.sqrt(
np.square(acc.Accelerometer_X) + np.square(acc.Accelerometer_Y) +
np.square(acc.Accelerometer_Z))
acc['total'] = acc['Accelerometer_X'] + acc['Accelerometer_Y'] + acc[
'Accelerometer_Z']
grav = np.median(acc.mag)
acc.Accelerometer_X = acc.Accelerometer_X / grav
acc.Accelerometer_Y = acc.Accelerometer_Y / grav
acc.Accelerometer_Z = acc.Accelerometer_Z / grav
acc.dropna()
return ecg, acc, sample_rate
def extract_ecg(edf_file, copy_folder):
filename = os.path.basename(edf_file)
new_edf_file = os.path.join(copy_folder, filename)
if os.path.exists(new_edf_file): return
try:
header = highlevel.read_edf_header(edf_file)
except:
print(f'error in file {edf_file}')
return
channels = header['channels']
try:
channels.remove('cs_ECG')
except:
print(f'warning, {edf_file} has no cs_ECG')
ch_names = [x for x in channels if 'ECG' in x.upper()]
if len(ch_names) > 1:
print(
f'Warning, these are present: {ch_names}, selecting {ch_names[0]}')
ch_name = ch_names[0]
signals, shead, header = highlevel.read_edf(edf_file,
ch_names=[ch_name],
digital=True,
verbose=False)
shead[0]['label'] = 'ECG'
assert len(signals) > 0, 'signal empty'
try:
highlevel.write_edf(new_edf_file, signals, shead, header, digital=True)
except:
shead[0]['digital_min'] = signals.min()
shead[0]['digital_max'] = signals.max()
highlevel.write_edf(new_edf_file, signals, shead, header, digital=True)
def test_read_unicode(self):
signals = np.random.rand(3, 256*60)
success = highlevel.write_edf_quick(self.edfplus_data_file, signals, sfreq=256)
self.assertTrue(success)
shutil.copy(self.edfplus_data_file, self.test_unicode)
signals2, _, _ = highlevel.read_edf(self.test_unicode)
self.assertTrue(os.path.isfile(self.test_unicode), 'File does not exist')
def detect_energy_spikes():
seizure_file_1 = "/run/media/jmsvanrijn/3707BCE92020A60C/Data_2010_take_2/1.0.0/chb23/chb23_09.edf"
normal_file = "/run/media/jmsvanrijn/3707BCE92020A60C/Data_2010_take_2/1.0.0/chb23/chb23_10.edf"
start_time = 2000 # In seconds
end_time = 3000 # In seconds
hz = 256
signals, signal_headers, header = highlevel.read_edf(str(seizure_file_1))
recorded_seizures = np.array([0, 2589, 2660, 6885, 6947, 8505, 8532, 9580, 9664, len(signals[0])/hz])*hz
seiz_23_1 = [29, 47]
seiz_23_2 = [[30, 50], [53, 59]]
seiz_23_3 = [2, 90]
y_axis = np.resize([750, 0], len(recorded_seizures))
z = np.array(signals[2])
g = z[1:]**2 - z[1:]*z[:-1]
g_2 = np.convolve(g, [1, 1, 1, 1, 1, 1, 1, 1])
plt.subplot(211)
plt.plot(np.transpose(z))
plt.plot(recorded_seizures, y_axis, drawstyle="steps")
y_axis = np.resize([np.max(g), 0], len(recorded_seizures))
plt.subplot(212)
plt.plot(np.transpose(g))
plt.plot(np.transpose(g_2))
plt.plot(recorded_seizures, y_axis, drawstyle="steps")
plt.show()
def get_data(self, name, ignore_skip_status=False, reshape=256):
record = self.__get_record(name, ignore_skip_status=ignore_skip_status)
self.__download(name)
signals, _, _ = highlevel.read_edf('temp.edf')
channels = record['Channels']
signals = signals[channels]
return signals.T.reshape(-1, reshape, 23)
def test_read_write_accented(self):
signals = np.random.rand(3, 256*60)
highlevel.write_edf_quick(self.test_accented, signals, sfreq=256)
signals2, _, _ = highlevel.read_edf(self.test_accented)
np.testing.assert_allclose(signals, signals2, atol=0.00002)
# if os.name!='nt':
self.assertTrue(os.path.isfile(self.test_accented), 'File does not exist')
def __getitem__(self, index):
filename, label = self.items[index]
# t = time.time()
signals, signal_headers, header = highlevel.read_edf(filename)
# print(time.time()-t)
loc = random.randint(0, len(signals[0]) - self.window_size)
signals_cut = signals[:, loc: loc + self.window_size]
return signals_cut, int(label), filename
def pearson_correlation(indexed_normal, index_seizures):
frame_normal = pd.DataFrame(np.zeros((23, 23)))
frame_seiz = pd.DataFrame(np.zeros((23, 23)))
for i in range(len(index_seizures) - 150):
signal_nor, _, _ = highlevel.read_edf(str(indexed_normal[i][0]))
signal_seiz, _, _ = highlevel.read_edf(str(index_seizures[i][0]))
frame_normal = frame_normal.add(pd.DataFrame(signal_nor[:15 * 256]))
frame_seiz = frame_seiz.add(pd.DataFrame(signal_seiz[:15 * 256]))
# frame_normal = frame_normal.add(pd.DataFrame(abs(signal_nor)).T.corr())
# frame_seiz = frame_seiz.add(pd.DataFrame(abs(signal_seiz)).T.corr())
normal_corr = frame_normal.T.corr()
seiz_corr = frame_seiz.T.corr()
size = 23
high_correlation = frame_seiz.to_numpy()
lowest = np.argmin(high_correlation.reshape(-1), axis=0)
y_corr = math.floor(lowest / size)
x_corr = lowest % size
# plt.figure()
# plt.imshow(normal_corr, origin="lower", cmap="hot", interpolation="nearest")
# plt.colorbar()
#
# plt.figure()
# plt.imshow(seiz_corr, origin="lower", cmap="hot", interpolation="nearest")
# plt.colorbar()
#
# plt.figure()
# plt.imshow(np.abs(normal_corr), origin="lower", cmap="hot", interpolation="nearest")
# plt.colorbar()
#
# plt.figure()
# plt.imshow(np.abs(seiz_corr), origin="lower", cmap="hot", interpolation="nearest")
# plt.colorbar()
#
# plt.figure()
# plt.imshow(np.abs(seiz_corr)-np.abs(normal_corr), origin="lower", cmap="hot", interpolation="nearest")
# plt.colorbar()
# return x_corr, y_corr
return normal_corr
def __getitem__(self, index):
filename, label, start = self.items[index]
# t = time.time()
signals, signal_headers, header = highlevel.read_edf(filename)
# print(time.time()-t)
signal_cut = signals[:, int(start)*self.window_size: (int(start)+1)*self.window_size]
return signal_cut, int(label)
def max_per_file(path, window_size):
seizure_files = []
normal_files = []
for seizure in sorted(Path(path).glob('seizures/*.edf')):
signals, _, _ = highlevel.read_edf(str(seizure))
length_signals = int(math.floor(len(signals[0]) / window_size))
for i in range(length_signals):
seizure_files.append((str(seizure), str(1), str(i)))
for normal in sorted(Path(path).glob('normal/*.edf')):
signals, _, _ = highlevel.read_edf(str(normal))
length_signals = int(math.floor(len(signals[0]) / window_size))
for i in range(length_signals):
normal_files.append((str(normal), str(0), str(i)))
print(len(seizure_files + normal_files))
return random.sample((seizure_files + normal_files),
len((seizure_files + normal_files)))
def test_read_write_decimal_sample_rates(self):
signals = np.random.randint(-2048, 2048, [3, 256 * 60])
highlevel.write_edf_quick(self.edfplus_data_file,
signals.astype(np.int32),
sfreq=8.5,
digital=True)
signals2, _, _ = highlevel.read_edf(self.edfplus_data_file,
digital=True,
verbose=True)
np.testing.assert_allclose(signals, signals2)
signals = np.random.rand(3, 256 * 60)
highlevel.write_edf_quick(self.edfplus_data_file,
signals,
sfreq=8.5,
digital=False)
signals2, _, _ = highlevel.read_edf(self.edfplus_data_file,
digital=False,
verbose=True)
np.testing.assert_allclose(signals, signals2, atol=0.0001)
def _load(self, edf_file, mat_file=None):
if mat_file is None:
filename = ospath.basename(edf_file)[:-4]
folder = ospath.dirname(edf_file)
print(mat_file)
mat_file = ospath.list_files(folder, patterns=f'{filename}*.mat')
if len(mat_file)>0: mat_file = mat_file[0]
if not mat_file or not os.path.exists(mat_file):
print('matfile {} not found'.format(mat_file))
dir = ospath.dirname(edf_file)
mat_file = misc.choose_file(dir, exts='mat',
title='Select the corresponding MAT file by Kubios')
signals, sheader, header = highlevel.read_edf(edf_file, ch_names='ECG I')
sfreq = sheader[0]['sample_rate']
data = signals[0].squeeze()
stime = header['startdate']
self.starttime = (stime.hour * 60 + stime.minute) * 60 + stime.second
self.data = data
self.sfreq = sfreq
try:
mat = mat73.loadmat(mat_file, verbose=False)
rr = mat['Res']['HRV']['Data']['RR']
trrs = mat['Res']['HRV']['Data']['T_RR'] - self.starttime
rrorig = mat['Res']['HRV']['Data']['T_RRorig'] - self.starttime
corr = mat['Res']['HRV']['Data']['RRcorrtimes'] - self.starttime
art = mat['Res']['HRV']['TimeVar']['Artifacts']
altered = trrs[np.where(np.diff(trrs)!=rr)[0]]
except:
raise FileNotFoundError('Mat file not found.')
artefacts_file = edf_file[:-4] + '.npy'
if os.path.exists(artefacts_file):
self.artefacts = np.load(artefacts_file)
else:
art = np.nan_to_num(art, nan=99)
self.artefacts = np.repeat(art>self.threshold, repeats=2, axis=0).T.reshape([-1,2])
self.detect_flatline()
self.kubios_art = np.nan_to_num(art.squeeze())
self.mat = mat
self.altered = altered.squeeze()
self.rrorig = rrorig.squeeze()
self.trrs = trrs.squeeze()
print(trrs[:10])
self.corr = corr.squeeze()
self.file = edf_file
self.mat_file = mat_file
self.artefacts_file = artefacts_file
self.max_page = len(data)//sfreq//self.interval//self.gridsize
self.save()
def max_per_file_2(path, window_size):
all_files = []
for seizure in sorted(Path(path).glob('seizures/*.edf')):
signals, _, _ = highlevel.read_edf(str(seizure))
length_signals = int(math.floor(len(signals[0]) / window_size))
for i in range(length_signals):
all_files.append(
(signals[:, i * window_size:(i + 1) * window_size], 1))
for normal in sorted(Path(path).glob('normal/*.edf')):
signals, _, _ = highlevel.read_edf(str(normal))
length_signals = int(math.floor(len(signals[0]) / window_size))
for i in range(length_signals):
all_files.append(
(signals[:, i * window_size:(i + 1) * window_size], 0))
print(len(all_files))
return random.sample(all_files, len(all_files))
def __init__(self, file_name, sample_spacing, window_size):
signals, signal_headers, header = highlevel.read_edf(file_name)
self.sample_spacing = sample_spacing
self.window_size = window_size
self.signals = signals
self.items = range(
int(
len(signals[0]) / sample_spacing -
window_size / sample_spacing - 1))
self.length = len(self.items)
def get_edf(fname, channel):
signals, signal_headers, header = read_edf(fname)
chn = -1
for h in range(len(signal_headers)):
if signal_headers[h]['label'] == channel:
chn = h
if chn == -1:
raise ValueError(channel + " cannot be found in the given EDF.")
else:
sf = signal_headers[chn]['sample_rate']
b = signals[chn]
return b, sf
def test_read_write_diff_sfreq(self):
signals = []
sfreqs = [1, 64, 128, 200]
sheaders = []
for sfreq in sfreqs:
signals.append(np.random.randint(-2048, 2048, sfreq*60).astype(np.int32))
shead = highlevel.make_signal_header('ch{}'.format(sfreq), sample_rate=sfreq)
sheaders.append(shead)
highlevel.write_edf(self.edfplus_data_file, signals, sheaders, digital=True)
signals2, sheaders2, _ = highlevel.read_edf(self.edfplus_data_file, digital=True)
for s1, s2 in zip(signals, signals2):
np.testing.assert_allclose(s1, s2)
def test_annotation_bytestring(self):
header = highlevel.make_header(technician='tech',
recording_additional='radd',
patientname='name',
patient_additional='padd',
patientcode='42',
equipment='eeg',
admincode='420',
gender='Male',
birthdate='05.09.1980')
annotations = [[0.01, b'-1', 'begin'], [0.5, b'-1', 'middle'],
[10, -1, 'end']]
header['annotations'] = annotations
signal_headers = highlevel.make_signal_headers(
['ch' + str(i) for i in range(3)])
signals = np.random.rand(3, 256 * 300) * 200 #5 minutes of eeg
highlevel.write_edf(self.edfplus_data_file, signals, signal_headers,
header)
_, _, header2 = highlevel.read_edf(self.edfplus_data_file)
highlevel.write_edf(self.edfplus_data_file, signals, signal_headers,
header)
_, _, header3 = highlevel.read_edf(self.edfplus_data_file)
self.assertEqual(header2['annotations'], header3['annotations'])
def load_correlations(select_patients):
path = "/home/jmsvanrijn/Documents/Afstuderen/Code/low-power-epilepsy-detection/data/processed/"
index_seizures = [([
str(i),
str(i).split("/")[-1].split("_")[-3],
str(i).split("/")[-1].split("_")[-2]
]) for i in sorted(Path(path).glob('seizures/*.edf'))]
index_normal = [([
str(i),
str(i).split("/")[-1].split("_")[-3],
str(i).split("/")[-1].split("_")[-2]
]) for i in sorted(Path(path).glob('normal/*.edf'))]
seizures = []
normal = []
selected_seizures = []
selected_normal = []
for i, seizure in enumerate(index_seizures):
try:
patient_numbers = int(seizure[1][-2:])
except:
patient_numbers = int(seizure[1][-3:-1])
if patient_numbers in select_patients:
selected_seizures.append(seizure)
selected_normal.append(index_normal[i])
print("AoSeizures: " + str(len(selected_seizures)))
print("AoNormals: " + str(len(selected_normal)))
for i in range(len(selected_normal)):
signal_seiz, _, _ = highlevel.read_edf(str(selected_seizures[i][0]))
normal_seiz, _, _ = highlevel.read_edf(str(selected_normal[i][0]))
seizures.append((signal_seiz, str(1)))
normal.append((normal_seiz, str(0)))
return seizures, normal
def load_file(k=0, foldername="EEGMA/"):
fields = []
rows = []
with open(foldername + "subject-info.csv", 'r') as csvfile:
csvreader = csv.reader(csvfile)
fields = next(csvreader)
for row in csvreader:
rows.append(row)
#
try:
signals, signal_headers, header = highlevel.read_edf(foldername +
"Subject" +
str(k) + "_2.edf")
except:
signals, signal_headers, header = highlevel.read_edf(foldername +
"Subject0" +
str(k) + "_2.edf")
print("\n", fields[4], " | ", rows[k][0], " | ", rows[k][4])
print("######## --- > ")
return signals, signal_headers, header, fields, rows