Пример #1
0
    def test_anonymize(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, -1, 'begin'], [0.5, -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.personalized, signals, signal_headers, header)

        highlevel.anonymize_edf(self.personalized,
                                new_file=self.anonymized,
                                to_remove=[
                                    'patientname', 'birthdate', 'admincode',
                                    'patientcode', 'technician'
                                ],
                                new_values=['x', '', 'xx', 'xxx', 'xxxx'],
                                verify=True,
                                verbose=True)
        new_header = highlevel.read_edf_header(self.anonymized)
        self.assertEqual(new_header['birthdate'], '')
        self.assertEqual(new_header['patientname'], 'x')
        self.assertEqual(new_header['admincode'], 'xx')
        self.assertEqual(new_header['patientcode'], 'xxx')
        self.assertEqual(new_header['technician'], 'xxxx')

        highlevel.anonymize_edf(self.personalized,
                                to_remove=[
                                    'patientname', 'birthdate', 'admincode',
                                    'patientcode', 'technician'
                                ],
                                new_values=['x', '', 'xx', 'xxx', 'xxxx'],
                                verify=True)
        new_header = highlevel.read_edf_header(self.personalized[:-4] +
                                               '_anonymized.edf')
        self.assertEqual(new_header['birthdate'], '')
        self.assertEqual(new_header['patientname'], 'x')
        self.assertEqual(new_header['admincode'], 'xx')
        self.assertEqual(new_header['patientcode'], 'xxx')
        self.assertEqual(new_header['technician'], 'xxxx')

        with self.assertRaises(AssertionError):
            highlevel.anonymize_edf(self.personalized,
                                    new_file=self.anonymized,
                                    to_remove=[
                                        'patientname', 'birthdate',
                                        'admincode', 'patientcode',
                                        'technician'
                                    ],
                                    new_values=['x', '', 'xx', 'xxx'],
                                    verify=True)
Пример #2
0
    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)
Пример #3
0
    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)
Пример #4
0
 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'])