def test_read_ica_eeglab(): """Test read_ica_eeglab function.""" fname = op.join(test_base_dir, "EEGLAB", "test_raw.set") fname_cleaned_matlab = op.join(test_base_dir, "EEGLAB", "test_raw.cleaned.set") raw = read_raw_eeglab(fname, preload=True) raw_eeg = _check_load_mat(fname, None) raw_cleaned_matlab = read_raw_eeglab(fname_cleaned_matlab, preload=True) mark_to_remove = ["manual"] comp_info = raw_eeg.marks["comp_info"] if len(comp_info["flags"].shape) > 1: ind_comp_to_drop = [np.where(flags)[0] for flags, label in zip(comp_info["flags"], comp_info["label"]) if label in mark_to_remove] ind_comp_to_drop = np.unique(np.concatenate(ind_comp_to_drop)) else: ind_comp_to_drop = np.where(comp_info["flags"])[0] ica = read_ica_eeglab(fname) _assert_ica_attributes(ica) raw_cleaned = ica.apply(raw.copy(), exclude=ind_comp_to_drop) assert_allclose(raw_cleaned_matlab.get_data(), raw_cleaned.get_data(), rtol=1e-05, atol=1e-08)
def test_position_information(one_chanpos_fname): """Test reading file with 3 channels - one without position information.""" nan = np.nan EXPECTED_LOCATIONS_FROM_FILE = np.array([ [-4., 1., 7., 0., 0., 0., nan, nan, nan, nan, nan, nan], [-5., 2., 8., 0., 0., 0., nan, nan, nan, nan, nan, nan], [nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan], ]) EXPECTED_LOCATIONS_FROM_MONTAGE = np.array([ [nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan], [nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan], [nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan], ]) raw = read_raw_eeglab(input_fname=one_chanpos_fname, preload=True) assert_array_equal(np.array([ch['loc'] for ch in raw.info['chs']]), EXPECTED_LOCATIONS_FROM_FILE) # To accommodate the new behavior so that: # read_raw_eeglab(.. montage=montage) and raw.set_montage(montage) # behaves the same we need to flush the montage. otherwise we get # a mix of what is in montage and in the file raw = read_raw_eeglab( input_fname=one_chanpos_fname, preload=True, ).set_montage(None) # Flush the montage builtin within input_fname _assert_array_allclose_nan(np.array([ch['loc'] for ch in raw.info['chs']]), EXPECTED_LOCATIONS_FROM_MONTAGE) _assert_array_allclose_nan(np.array([ch['loc'] for ch in raw.info['chs']]), EXPECTED_LOCATIONS_FROM_MONTAGE)
def test_io_set(): """Test importing EEGLAB .set files""" from scipy import io _test_raw_reader(read_raw_eeglab, input_fname=raw_fname, montage=montage) with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') _test_raw_reader(read_raw_eeglab, input_fname=raw_fname_onefile, montage=montage) raw = read_raw_eeglab(input_fname=raw_fname_onefile, montage=montage) raw2 = read_raw_eeglab(input_fname=raw_fname, montage=montage) assert_array_equal(raw[:][0], raw2[:][0]) # one warning per each preload=False or str with raw_fname_onefile assert_equal(len(w), 3) with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') epochs = read_epochs_eeglab(epochs_fname) epochs2 = read_epochs_eeglab(epochs_fname_onefile) # 3 warnings for each read_epochs_eeglab because there are 3 epochs # associated with multiple events assert_equal(len(w), 6) assert_array_equal(epochs.get_data(), epochs2.get_data()) # test different combinations of events and event_ids temp_dir = _TempDir() out_fname = op.join(temp_dir, 'test-eve.fif') write_events(out_fname, epochs.events) event_id = {'S255/S8': 1, 'S8': 2, 'S255/S9': 3} epochs = read_epochs_eeglab(epochs_fname, epochs.events, event_id) epochs = read_epochs_eeglab(epochs_fname, out_fname, event_id) assert_raises(ValueError, read_epochs_eeglab, epochs_fname, None, event_id) assert_raises(ValueError, read_epochs_eeglab, epochs_fname, epochs.events, None) # test if .dat file raises an error eeg = io.loadmat(epochs_fname, struct_as_record=False, squeeze_me=True)['EEG'] eeg.data = 'epochs_fname.dat' bad_epochs_fname = op.join(temp_dir, 'test_epochs.set') io.savemat(bad_epochs_fname, {'EEG': {'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': eeg.nbchan, 'data': eeg.data, 'epoch': eeg.epoch, 'event': eeg.event, 'chanlocs': eeg.chanlocs}}) shutil.copyfile(op.join(base_dir, 'test_epochs.fdt'), op.join(temp_dir, 'test_epochs.dat')) with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') assert_raises(NotImplementedError, read_epochs_eeglab, bad_epochs_fname) assert_equal(len(w), 3)
def test_io_set_raw(fname): """Test importing EEGLAB .set files.""" _test_raw_reader(read_raw_eeglab, input_fname=fname, montage=montage) # test that preloading works raw0 = read_raw_eeglab(input_fname=fname, montage=montage, preload=True) raw0.filter(1, None, l_trans_bandwidth='auto', filter_length='auto', phase='zero') # test that using uint16_codec does not break stuff raw0 = read_raw_eeglab(input_fname=fname, montage=montage, preload=False, uint16_codec='ascii')
def test_montage(): """Test montage.""" fname = op.join(base_dir, 'test_raw.set') raw_none = read_raw_eeglab(input_fname=fname, montage=None, preload=False) montage = _fake_montage(raw_none.info['ch_names']) raw_montage = read_raw_eeglab(input_fname=fname, montage=montage, preload=False) raw_none.set_montage(montage) # Check they are the same assert_array_equal(raw_none.get_data(), raw_montage.get_data()) assert object_diff(raw_none.info['dig'], raw_montage.info['dig']) == '' assert object_diff(raw_none.info['chs'], raw_montage.info['chs']) == ''
def test_1020_selection(): """Test making a 10/20 selection dict.""" base_dir = op.join(testing.data_path(download=False), 'EEGLAB') raw_fname = op.join(base_dir, 'test_raw.set') loc_fname = op.join(base_dir, 'test_chans.locs') raw = read_raw_eeglab(raw_fname, preload=True) montage = read_custom_montage(loc_fname) raw = raw.rename_channels(dict(zip(raw.ch_names, montage.ch_names))) raw.set_montage(montage) for input in ("a_string", 100, raw, [1, 2]): pytest.raises(TypeError, make_1020_channel_selections, input) sels = make_1020_channel_selections(raw.info) # are all frontal channels placed before all occipital channels? for name, picks in sels.items(): fs = min([ ii for ii, pick in enumerate(picks) if raw.ch_names[pick].startswith("F") ]) ps = max([ ii for ii, pick in enumerate(picks) if raw.ch_names[pick].startswith("O") ]) assert fs > ps # are channels in the correct selection? fz_c3_c4 = [raw.ch_names.index(ch) for ch in ("Fz", "C3", "C4")] for channel, roi in zip(fz_c3_c4, ("Midline", "Left", "Right")): assert channel in sels[roi]
def read_raw_eeglab_from_source(source: str, channels_to_drop=None) -> Raw: ''' Read raw EEGLAB .set data from source Args: str source: Path to .set data list channels_to_drop: The list of channel names to drop (EOG channels) :return: Raw raw: The object containing EEGLAB .set data See Also -------- mne.io.read_raw_eeglab : Documentation of parameters. ''' try: raw = read_raw_eeglab(source, preload=True).set_annotations(None) except Exception as e: logging.error(f'Error while trying to read {source}, error: {e}') raise if channels_to_drop is not None: matched_channels = [] for channel in channels_to_drop: matched_channels.extend([ raw_ch_name for raw_ch_name in raw.ch_names if channel in raw_ch_name ]) raw = raw.drop_channels(ch_names=matched_channels) return raw
def test_export_raw_eeglab(tmp_path): """Test saving a Raw instance to EEGLAB's set format.""" raw = read_raw_fif(fname_raw, preload=True) raw.apply_proj() temp_fname = op.join(str(tmp_path), 'test.set') raw.export(temp_fname) raw.drop_channels([ch for ch in ['epoc'] if ch in raw.ch_names]) raw_read = read_raw_eeglab(temp_fname, preload=True) assert raw.ch_names == raw_read.ch_names cart_coords = np.array([d['loc'][:3] for d in raw.info['chs']]) # just xyz cart_coords_read = np.array([d['loc'][:3] for d in raw_read.info['chs']]) assert_allclose(cart_coords, cart_coords_read) assert_allclose(raw.times, raw_read.times) assert_allclose(raw.get_data(), raw_read.get_data()) # test overwrite with pytest.raises(FileExistsError, match='Destination file exists'): raw.export(temp_fname, overwrite=False) raw.export(temp_fname, overwrite=True) # test pathlib.Path files raw.export(Path(temp_fname), overwrite=True) # test warning with unapplied projectors raw = read_raw_fif(fname_raw, preload=True) with pytest.warns(RuntimeWarning, match='Raw instance has unapplied projectors.'): raw.export(temp_fname, overwrite=True)
def test_ica_eeg(): """Test ICA on EEG.""" method = 'fastica' raw_fif = read_raw_fif(fif_fname, preload=True) raw_eeglab = read_raw_eeglab(input_fname=eeglab_fname, preload=True) for raw in [raw_fif, raw_eeglab]: events = make_fixed_length_events(raw, 99999, start=0, stop=0.3, duration=0.1) picks_meg = pick_types(raw.info, meg=True, eeg=False)[:2] picks_eeg = pick_types(raw.info, meg=False, eeg=True)[:2] picks_all = [] picks_all.extend(picks_meg) picks_all.extend(picks_eeg) epochs = Epochs(raw, events, None, -0.1, 0.1, preload=True) evoked = epochs.average() for picks in [picks_meg, picks_eeg, picks_all]: if len(picks) == 0: continue # test fit for inst in [raw, epochs]: ica = ICA(n_components=2, random_state=0, max_iter=2, method=method) with pytest.warns(None): ica.fit(inst, picks=picks) _assert_ica_attributes(ica) # test apply and get_sources for inst in [raw, epochs, evoked]: ica.apply(inst) ica.get_sources(inst) with pytest.warns(RuntimeWarning, match='MISC channel'): raw = read_raw_ctf(ctf_fname2, preload=True) events = make_fixed_length_events(raw, 99999, start=0, stop=0.2, duration=0.1) picks_meg = pick_types(raw.info, meg=True, eeg=False)[:2] picks_eeg = pick_types(raw.info, meg=False, eeg=True)[:2] picks_all = picks_meg + picks_eeg for comp in [0, 1]: raw.apply_gradient_compensation(comp) epochs = Epochs(raw, events, None, -0.1, 0.1, preload=True) evoked = epochs.average() for picks in [picks_meg, picks_eeg, picks_all]: if len(picks) == 0: continue # test fit for inst in [raw, epochs]: ica = ICA(n_components=2, random_state=0, max_iter=2, method=method) with pytest.warns(None): ica.fit(inst) _assert_ica_attributes(ica) # test apply and get_sources for inst in [raw, epochs, evoked]: ica.apply(inst) ica.get_sources(inst)
def test_io_set_raw(fname): """Test importing EEGLAB .set files.""" montage = _read_eeglab_montage(montage_path) montage.ch_names = [ 'EEG {0:03d}'.format(ii) for ii in range(len(montage.ch_names)) ] kws = dict(reader=read_raw_eeglab, input_fname=fname) if fname.endswith('test_raw_chanloc.set'): with pytest.warns(RuntimeWarning, match="The data contains 'boundary' events"): raw0 = _test_raw_reader(**kws) elif '_h5' in fname: # should be safe enough, and much faster raw0 = read_raw_eeglab(fname, preload=True) else: raw0 = _test_raw_reader(**kws) # test that preloading works if fname.endswith('test_raw_chanloc.set'): raw0.set_montage(montage, on_missing='ignore') # crop to check if the data has been properly preloaded; we cannot # filter as the snippet of raw data is very short raw0.crop(0, 1) else: raw0.set_montage(montage) raw0.filter(1, None, l_trans_bandwidth='auto', filter_length='auto', phase='zero') # test that using uint16_codec does not break stuff read_raw_kws = dict(input_fname=fname, preload=False, uint16_codec='ascii') if fname.endswith('test_raw_chanloc.set'): with pytest.warns(RuntimeWarning, match="The data contains 'boundary' events"): raw0 = read_raw_eeglab(**read_raw_kws) raw0.set_montage(montage, on_missing='ignore') else: raw0 = read_raw_eeglab(**read_raw_kws) raw0.set_montage(montage) # Annotations if fname != raw_fname_chanloc: assert len(raw0.annotations) == 154 assert set(raw0.annotations.description) == {'rt', 'square'} assert_array_equal(raw0.annotations.duration, 0.)
def test_position_information(one_chanpos_fname): """Test reading file with 3 channels - one without position information.""" nan = np.nan EXPECTED_LOCATIONS_FROM_FILE = np.array([ [-4., 1., 7., 0., 0., 0., 0., 0., 0., 0., 0., 0.], [-5., 2., 8., 0., 0., 0., 0., 0., 0., 0., 0., 0.], [nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan], ]) EXPECTED_LOCATIONS_FROM_MONTAGE = np.array([ [-0.56705965, 0.67706631, 0.46906776, 0, 0, 0, 0, 0, 0, 0, 0, 0], [nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan], [0, 0.99977915, -0.02101571, 0, 0, 0, 0, 0, 0, 0, 0, 0], ]) raw = read_raw_eeglab(input_fname=one_chanpos_fname, preload=True) assert_array_equal(np.array([ch['loc'] for ch in raw.info['chs']]), EXPECTED_LOCATIONS_FROM_FILE) raw = read_raw_eeglab(input_fname=one_chanpos_fname, preload=True) if montage is not None: raw.set_montage(None) # flushing raw.set_montage(montage, update_ch_names=False) _assert_array_allclose_nan(np.array([ch['loc'] for ch in raw.info['chs']]), EXPECTED_LOCATIONS_FROM_MONTAGE) # To acomodate the new behavior so that: # read_raw_eeglab(.. montage=montage) and raw.set_montage(montage) # behaves the same we need to flush the montage. otherwise we get # a mix of what is in montage and in the file foo = read_raw_eeglab(input_fname=one_chanpos_fname, preload=True) foo.set_montage(None) # flushing foo.set_montage(montage, update_ch_names=False) _assert_array_allclose_nan(np.array([ch['loc'] for ch in foo.info['chs']]), EXPECTED_LOCATIONS_FROM_MONTAGE) # Mixed montage: from the file and from montage foo = read_raw_eeglab(input_fname=one_chanpos_fname, preload=True) foo.set_montage(montage, update_ch_names=False) mixed = np.array([ [-0.56705965, 0.67706631, 0.46906776, 0, 0, 0, 0, 0, 0, 0, 0, 0], [-5., 2., 8., 0., 0., 0., 0., 0., 0., 0., 0., 0.], [0, 0.99977915, -0.02101571, 0, 0, 0, 0, 0, 0, 0, 0, 0], ]) _assert_array_allclose_nan(np.array([ch['loc'] for ch in foo.info['chs']]), mixed)
def test_ica_eeg(): """Test ICA on EEG.""" method = 'fastica' raw_fif = read_raw_fif(fif_fname, preload=True) with pytest.warns(RuntimeWarning, match='events'): raw_eeglab = read_raw_eeglab(input_fname=eeglab_fname, montage=eeglab_montage, preload=True) for raw in [raw_fif, raw_eeglab]: events = make_fixed_length_events(raw, 99999, start=0, stop=0.3, duration=0.1) picks_meg = pick_types(raw.info, meg=True, eeg=False)[:2] picks_eeg = pick_types(raw.info, meg=False, eeg=True)[:2] picks_all = [] picks_all.extend(picks_meg) picks_all.extend(picks_eeg) epochs = Epochs(raw, events, None, -0.1, 0.1, preload=True) evoked = epochs.average() for picks in [picks_meg, picks_eeg, picks_all]: if len(picks) == 0: continue # test fit for inst in [raw, epochs]: ica = ICA(n_components=2, random_state=0, max_iter=2, method=method) with pytest.warns(None): ica.fit(inst, picks=picks) # test apply and get_sources for inst in [raw, epochs, evoked]: ica.apply(inst) ica.get_sources(inst) with pytest.warns(RuntimeWarning, match='MISC channel'): raw = read_raw_ctf(ctf_fname2, preload=True) events = make_fixed_length_events(raw, 99999, start=0, stop=0.2, duration=0.1) picks_meg = pick_types(raw.info, meg=True, eeg=False)[:2] picks_eeg = pick_types(raw.info, meg=False, eeg=True)[:2] picks_all = picks_meg + picks_eeg for comp in [0, 1]: raw.apply_gradient_compensation(comp) epochs = Epochs(raw, events, None, -0.1, 0.1, preload=True) evoked = epochs.average() for picks in [picks_meg, picks_eeg, picks_all]: if len(picks) == 0: continue # test fit for inst in [raw, epochs]: ica = ICA(n_components=2, random_state=0, max_iter=2, method=method) with pytest.warns(None): ica.fit(inst) # test apply and get_sources for inst in [raw, epochs, evoked]: ica.apply(inst) ica.get_sources(inst)
def plot_data(self): if self.fname == '': self.log_print('There is no file selected. Please select a file\n') print('There is no file selected. Please select a file') else: self.log_print('Plotting data...') raw = io.read_raw_eeglab(str(self.fname)) #109_raw.set raw.plot(block=True)
def test_io_set_raw(fname): """Test importing EEGLAB .set files.""" montage = _read_eeglab_montage(montage_path) montage.ch_names = [ 'EEG {0:03d}'.format(ii) for ii in range(len(montage.ch_names)) ] _test_raw_reader(read_raw_eeglab, input_fname=fname) # test that preloading works raw0 = read_raw_eeglab(input_fname=fname, preload=True) raw0.set_montage(montage) raw0.filter(1, None, l_trans_bandwidth='auto', filter_length='auto', phase='zero') # test that using uint16_codec does not break stuff raw0 = read_raw_eeglab(input_fname=fname, preload=False, uint16_codec='ascii') raw0.set_montage(montage)
def test_io_set_raw(fname): """Test importing EEGLAB .set files.""" montage = _read_eeglab_montage(montage_path) montage.ch_names = [ 'EEG {0:03d}'.format(ii) for ii in range(len(montage.ch_names)) ] kws = dict(reader=read_raw_eeglab, input_fname=fname) if fname.endswith('test_raw_chanloc.set'): with pytest.warns(RuntimeWarning, match="The data contains 'boundary' events"): _test_raw_reader(**kws) else: _test_raw_reader(**kws) # test that preloading works read_raw_kws = dict(input_fname=fname, preload=True) if fname.endswith('test_raw_chanloc.set'): with pytest.warns(RuntimeWarning, match="The data contains 'boundary' events"): raw0 = read_raw_eeglab(**read_raw_kws) raw0.set_montage(montage, on_missing='ignore') # crop to check if the data has been properly preloaded; we cannot # filter as the snippet of raw data is very short raw0.crop(0, 1) else: raw0 = read_raw_eeglab(**read_raw_kws) raw0.set_montage(montage) raw0.filter(1, None, l_trans_bandwidth='auto', filter_length='auto', phase='zero') # test that using uint16_codec does not break stuff read_raw_kws = dict(input_fname=fname, preload=False, uint16_codec='ascii') if fname.endswith('test_raw_chanloc.set'): with pytest.warns(RuntimeWarning, match="The data contains 'boundary' events"): raw0 = read_raw_eeglab(**read_raw_kws) raw0.set_montage(montage, on_missing='ignore') else: raw0 = read_raw_eeglab(**read_raw_kws) raw0.set_montage(montage)
def test_montage(): """Test montage.""" base_dir = op.join(testing.data_path(download=False), 'EEGLAB') fname = op.join(base_dir, 'test_raw.set') # montage = op.join(base_dir, 'test_chans.locs') raw_none = read_raw_eeglab(input_fname=fname, montage=None, preload=False) montage = _fake_montage(raw_none.info['ch_names']) raw_montage = read_raw_eeglab(input_fname=fname, montage=montage, preload=False) raw_none.set_montage(montage) assert object_diff(raw_none.info['dig'], raw_montage.info['dig']) == '' # assert object_diff(raw_none.info['chs'], raw_montage.info['chs']) == '' diff = object_diff(raw_none.info['chs'], raw_montage.info['chs']).splitlines() for dd in diff: assert 'coord_frame' in dd
def frequency_filter(self, fname, lfreq, hfreq): if fname == '': self.log_print('There is no file selected. Please select a file\n') print('There is no file selected. Please select a file') else: fname = io.read_raw_eeglab(str(fname)) fname.load_data() fname.filter(lfreq, hfreq) fname.plot() self.log_print('Filter applied\n') print('Filter applied')
def test_fidsposition_information(): """Test reading file with 3 fiducial locations.""" raw = read_raw_eeglab(raw_fname_chanloc_fids) montage = raw.get_montage() pos = montage.get_positions() assert pos['nasion'] is not None assert pos['lpa'] is not None assert pos['rpa'] is not None assert len(pos['nasion']) == 3 assert len(pos['lpa']) == 3 assert len(pos['rpa']) == 3
def test_eeglab_event_from_annot(): """Test all forms of obtaining annotations.""" raw_fname_mat = op.join(base_dir, 'test_raw.set') raw_fname = raw_fname_mat event_id = {'rt': 1, 'square': 2} raw1 = read_raw_eeglab(input_fname=raw_fname, preload=False) annotations = read_annotations(raw_fname) assert len(raw1.annotations) == 154 raw1.set_annotations(annotations) events_b, _ = events_from_annotations(raw1, event_id=event_id) assert len(events_b) == 154
def test_position_information(one_chanpos_fname): """Test reading file with 3 channels - one without position information.""" nan = np.nan EXPECTED_LOCATIONS_FROM_FILE = np.array([ [-4., 1., 7., 0., 0., 0., 0., 0., 0., 0., 0., 0.], [-5., 2., 8., 0., 0., 0., 0., 0., 0., 0., 0., 0.], [nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan], ]) EXPECTED_LOCATIONS_FROM_MONTAGE = np.array([ [-0.56705965, 0.67706631, 0.46906776, 0, 0, 0, 0, 0, 0, 0, 0, 0], [nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan], [0, 0.99977915, -0.02101571, 0, 0, 0, 0, 0, 0, 0, 0, 0], ]) montage = _read_eeglab_montage(montage_path) raw = read_raw_eeglab(input_fname=one_chanpos_fname, preload=True) assert_array_equal(np.array([ch['loc'] for ch in raw.info['chs']]), EXPECTED_LOCATIONS_FROM_FILE) # To acomodate the new behavior so that: # read_raw_eeglab(.. montage=montage) and raw.set_montage(montage) # behaves the same we need to flush the montage. otherwise we get # a mix of what is in montage and in the file raw = read_raw_eeglab( input_fname=one_chanpos_fname, preload=True, ).set_montage(None) # Flush the montage builtin within input_fname with pytest.raises(ValueError): raw.set_montage(montage, update_ch_names=False) _msg = ( 'DigMontage is a only a subset of info. ' 'Did not set 1 channel positions:\nunknown' ) with pytest.warns(RuntimeWarning, match=_msg): raw.set_montage(montage, update_ch_names=False, raise_if_subset=False) _assert_array_allclose_nan(np.array([ch['loc'] for ch in raw.info['chs']]), EXPECTED_LOCATIONS_FROM_MONTAGE)
def test_eeglab_read_annotations(): """Test annotations onsets are timestamps (+ validate some).""" annotations = read_annotations(raw_fname_mat) validation_samples = [0, 1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31] expected_onset = np.array([1.00, 1.69, 2.08, 4.70, 7.71, 11.30, 17.18, 20.20, 26.12, 29.14, 35.25, 44.30, 47.15]) assert annotations.orig_time is None assert_array_almost_equal(annotations.onset[validation_samples], expected_onset, decimal=2) # test if event durations are imported correctly raw = read_raw_eeglab(raw_fname_event_duration, preload=True) # file contains 3 annotations with 0.5 s (64 samples) duration each assert_allclose(raw.annotations.duration, np.ones(3) * 0.5)
def test_eeglab_event_from_annot(): """Test all forms of obtaining annotations.""" base_dir = op.join(testing.data_path(download=False), 'EEGLAB') raw_fname_mat = op.join(base_dir, 'test_raw.set') raw_fname = raw_fname_mat montage = op.join(base_dir, 'test_chans.locs') event_id = {'rt': 1, 'square': 2} raw1 = read_raw_eeglab(input_fname=raw_fname, montage=montage, preload=False) annotations = read_annotations(raw_fname) assert len(raw1.annotations) == 154 raw1.set_annotations(annotations) events_b, _ = events_from_annotations(raw1, event_id=event_id) assert len(events_b) == 154
def test_export_eeglab(tmpdir): """Test saving a Raw instance to EEGLAB's set format.""" fname = Path(__file__).parent / "data" / "test_raw.fif" raw = read_raw_fif(fname) raw.load_data() temp_fname = op.join(str(tmpdir), 'test.set') raw.export(temp_fname) raw.drop_channels([ch for ch in ['epoc'] if ch in raw.ch_names]) raw_read = read_raw_eeglab(temp_fname, preload=True) assert raw.ch_names == raw_read.ch_names cart_coords = np.array([d['loc'][:3] for d in raw.info['chs']]) # just xyz cart_coords_read = np.array([d['loc'][:3] for d in raw_read.info['chs']]) assert_allclose(cart_coords, cart_coords_read) assert_allclose(raw.times, raw_read.times) assert_allclose(raw.get_data(), raw_read.get_data())
def test_eeglab_event_from_annot(recwarn): """Test all forms of obtaining annotations.""" base_dir = op.join(testing.data_path(download=False), 'EEGLAB') raw_fname_mat = op.join(base_dir, 'test_raw.set') raw_fname = raw_fname_mat montage = op.join(base_dir, 'test_chans.locs') event_id = {'rt': 1, 'square': 2} raw1 = read_raw_eeglab(input_fname=raw_fname, montage=montage, event_id=event_id, preload=False) events_a = find_events(raw1) events_b = read_events_eeglab(raw_fname, event_id=event_id) annotations = read_annotations_eeglab(raw_fname) assert raw1.annotations is None raw1.set_annotations(annotations) events_c, _ = events_from_annotations(raw1, event_id=event_id) assert_array_equal(events_a, events_b) assert_array_equal(events_a, events_c)
def _get_single_subject_data( self, subject: Union[str, int], verbose: Optional[Union[bool, str, int]] = None ) -> Dict[str, Dict[str, Raw]]: dests = self.data_path(subject) # DON'T KNOW CHANNEL NAMES!!! # montage = make_standard_montage('standard_1005') # montage.ch_names = [ch_name.upper() for ch_name in montage.ch_names] sess = dict() for isess, run_dests in enumerate(dests): runs = dict() for irun, run_array in enumerate(run_dests): raw = read_raw_eeglab(run_array, preload=True) raw = upper_ch_names(raw) # raw.set_montage(montage) raw.annotations.delete(0) runs['run_{:d}'.format(irun)] = raw sess['session_{:d}'.format(isess)] = runs return sess
def test_eeglab_event_from_annot(): """Test all forms of obtaining annotations.""" base_dir = op.join(testing.data_path(download=False), 'EEGLAB') raw_fname_mat = op.join(base_dir, 'test_raw.set') raw_fname = raw_fname_mat montage = op.join(base_dir, 'test_chans.locs') event_id = {'rt': 1, 'square': 2} with pytest.deprecated_call(match='stim_channel'): raw1 = read_raw_eeglab(input_fname=raw_fname, montage=montage, event_id=event_id, preload=False) events_a = find_events(raw1) with pytest.deprecated_call(match='read_events_eeglab'): events_b = read_events_eeglab(raw_fname, event_id=event_id) annotations = read_annotations(raw_fname) assert len(raw1.annotations) == 154 raw1.set_annotations(annotations) events_c, _ = events_from_annotations(raw1, event_id=event_id) assert_array_equal(events_a, events_b) assert_array_equal(events_a, events_c)
def test_1020_selection(): """Test making a 10/20 selection dict.""" base_dir = op.join(testing.data_path(download=False), 'EEGLAB') raw_fname = op.join(base_dir, 'test_raw.set') loc_fname = op.join(base_dir, 'test_chans.locs') raw = read_raw_eeglab(raw_fname, montage=loc_fname) for input in ("a_string", 100, raw, [1, 2]): pytest.raises(TypeError, make_1020_channel_selections, input) sels = make_1020_channel_selections(raw.info) # are all frontal channels placed before all occipital channels? for name, picks in sels.items(): fs = min([ii for ii, pick in enumerate(picks) if raw.ch_names[pick].startswith("F")]) ps = max([ii for ii, pick in enumerate(picks) if raw.ch_names[pick].startswith("O")]) assert fs > ps # are channels in the correct selection? fz_c3_c4 = [raw.ch_names.index(ch) for ch in ("Fz", "C3", "C4")] for channel, roi in zip(fz_c3_c4, ("Midline", "Left", "Right")): assert channel in sels[roi]
def read_info(path): from PySide2.QtCore import QUrl from mne.io import read_raw_cnt, read_raw_eeglab list_path = [QUrl(i).toLocalFile() for i in path] try: raw = { k: read_raw_cnt(k, montage=None, preload=True, stim_channel=False, verbose=None) if k.endswith("cnt") else read_raw_eeglab(k, montage=None, preload=True, stim_channel=False, verbose=None) for k in list_path } info = list() sfreq = list() for signal in raw: raw_info = raw[signal].info info.append(raw_info['subject_info']) sfreq.append(raw_info['sfreq']) del raw return info, sfreq except IOError: print('An error occurred trying to read the file.') except ImportError: print('No file found.') except: print('Cant read file') finally: print('Upload info correctly')
def test_export_raw_eeglab(tmp_path): """Test saving a Raw instance to EEGLAB's set format.""" fname = (Path(__file__).parent.parent.parent / "io" / "tests" / "data" / "test_raw.fif") raw = read_raw_fif(fname) raw.load_data() temp_fname = op.join(str(tmp_path), 'test.set') raw.export(temp_fname) raw.drop_channels([ch for ch in ['epoc'] if ch in raw.ch_names]) raw_read = read_raw_eeglab(temp_fname, preload=True) assert raw.ch_names == raw_read.ch_names cart_coords = np.array([d['loc'][:3] for d in raw.info['chs']]) # just xyz cart_coords_read = np.array([d['loc'][:3] for d in raw_read.info['chs']]) assert_allclose(cart_coords, cart_coords_read) assert_allclose(raw.times, raw_read.times) assert_allclose(raw.get_data(), raw_read.get_data()) # test overwrite with pytest.raises(FileExistsError, match='Destination file exists'): raw.export(temp_fname, overwrite=False) raw.export(temp_fname, overwrite=True) # test pathlib.Path files raw.export(Path(temp_fname), overwrite=True)
def read_raw(path): """ :rtype: object :param path: Path of the files that contain the signal :return: """ from PySide2.QtCore import QUrl from mne.io import read_raw_cnt, read_raw_eeglab import numpy as np import os # list_path = path.split(',') list_path = [QUrl(i).toLocalFile() for i in path] print(f'Signal path list: {list_path}') try: # Read raw signal raw = { k: read_raw_cnt(k, montage=None, preload=True, stim_channel=False, verbose=None) if k.endswith("cnt") else read_raw_eeglab(k, montage=None, preload=True, stim_channel=False, verbose=None) for k in list_path } # raw = {k: read_raw_cnt(k, montage = None, preload = True, # stim_channel = False, verbose = None) for k in list_path} # Print the multiples upload signals for signal in raw: print(f'\033[1;32;40m {raw[signal]} \033[0m \n') print(f'\033[1;33;40m {raw[signal].info} \033[0m \n') b = [] value_path = [] # Values in a numpy array in a dict way raw2np = {i: np.squeeze(raw[i].get_data()) for i in raw } # This contain the entire already uploaded data for keys in raw2np.keys(): print(f'\033[1;32;40m Key: {keys} \033[0m \n ') print(f'\033[1;35;40m Values: {raw2np[keys]} \033[0m \n') np_path = str(keys).replace( '.cnt' if str(keys).endswith('cnt') else '.set', '.npz') print('Path keys ', np_path) np.savez_compressed(np_path, raw2np[keys]) # print(np.load(np_path)) # Organizar esto en otro hilo pero bien organizado para cargarlo despues value_path.append(os.path.join(os.getcwd(), np_path)) b.append( np.load(np_path) ) # List with the values, each position is a different file print(f'Value path: {value_path}') # Update in settings the value path print(os.getcwd() + "--" + str(keys)) # print(b.__len__(), b[0].shape, b[1].shape) return value_path except IOError: print('An error occurred trying to read the file.') except ImportError: print('No file found.') except: print('Cant read file') finally: print('Upload signal(s) correctly')
def mne_switch(file, ext, downsample, preload=True, **kwargs): """Read sleep datasets using mne.io. Parameters ---------- file : string Filename (without extension). ext : string File extension (e.g. '.edf''). preload : bool | True Preload data in memory. kwargs : dict | {} Further arguments to pass to the mne.io.read function. Returns ------- sf : float The original sampling-frequency. downsample : float The down-sampling frequency used. dsf : int The down-sampling factor. data : array_like The raw data of shape (n_channels, n_points) channels : list List of channel names. n : int Number of time points before down-sampling. start_time : datetime.time The time offset. """ from mne import io # Get full path : path = file + ext # Preload : if preload is False: preload = 'temp.dat' kwargs['preload'] = preload if ext.lower() in ['.edf', '.bdf', '.gdf']: # EDF / BDF / GDF raw = io.read_raw_edf(path, **kwargs) elif ext.lower == '.set': # EEGLAB raw = io.read_raw_eeglab(path, **kwargs) elif ext.lower() in ['.egi', '.mff']: # EGI / MFF raw = io.read_raw_egi(path, **kwargs) elif ext.lower() == '.cnt': # CNT raw = io.read_raw_cnt(path, **kwargs) elif ext.lower() == '.vhdr': # BrainVision raw = io.read_raw_brainvision(path, **kwargs) else: raise IOError("File not supported by mne-python.") raw.pick_types(meg=True, eeg=True, ecg=True, emg=True) # Remove stim lines sf = raw.info['sfreq'] dsf, downsample = get_dsf(downsample, sf) channels = raw.info['ch_names'] data = raw._data # Conversion Volt (MNE) to microVolt (Visbrain): if raw._raw_extras[0] is not None and 'units' in raw._raw_extras[0]: units = raw._raw_extras[0]['units'][0:data.shape[0]] data /= np.array(units).reshape(-1, 1) n = data.shape[1] start_time = datetime.time(0, 0, 0) # raw.info['meas_date'] anot = raw.annotations return sf, downsample, dsf, data[:, ::dsf], channels, n, start_time, anot
def test_io_set(): """Test importing EEGLAB .set files.""" with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') # main tests, and test missing event_id _test_raw_reader(read_raw_eeglab, input_fname=raw_fname, montage=montage) _test_raw_reader(read_raw_eeglab, input_fname=raw_fname_onefile, montage=montage) for want in ('Events like', 'consist entirely', 'could not be mapped', 'string preload is not supported'): assert_true(any(want in str(ww.message) for ww in w)) with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') # test finding events in continuous data event_id = {'rt': 1, 'square': 2} raw0 = read_raw_eeglab(input_fname=raw_fname, montage=montage, event_id=event_id, preload=True) raw1 = read_raw_eeglab(input_fname=raw_fname, montage=montage, event_id=event_id, preload=False) raw2 = read_raw_eeglab(input_fname=raw_fname_onefile, montage=montage, event_id=event_id) raw3 = read_raw_eeglab(input_fname=raw_fname, montage=montage, event_id=event_id) raw4 = read_raw_eeglab(input_fname=raw_fname, montage=montage) Epochs(raw0, find_events(raw0), event_id) epochs = Epochs(raw1, find_events(raw1), event_id) assert_equal(len(find_events(raw4)), 0) # no events without event_id assert_equal(epochs["square"].average().nave, 80) # 80 with assert_array_equal(raw0[:][0], raw1[:][0], raw2[:][0], raw3[:][0]) assert_array_equal(raw0[:][-1], raw1[:][-1], raw2[:][-1], raw3[:][-1]) assert_equal(len(w), 4) # 1 for preload=False / str with fname_onefile, 3 for dropped events raw0.filter(1, None, l_trans_bandwidth='auto', filter_length='auto', phase='zero') # test that preloading works # test that using uint16_codec does not break stuff raw0 = read_raw_eeglab(input_fname=raw_fname, montage=montage, event_id=event_id, preload=False, uint16_codec='ascii') # test old EEGLAB version event import eeg = io.loadmat(raw_fname, struct_as_record=False, squeeze_me=True)['EEG'] for event in eeg.event: # old version allows integer events event.type = 1 assert_equal(read_events_eeglab(eeg)[-1, -1], 1) eeg.event = eeg.event[0] # single event assert_equal(read_events_eeglab(eeg)[-1, -1], 1) with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') epochs = read_epochs_eeglab(epochs_fname) epochs2 = read_epochs_eeglab(epochs_fname_onefile) # one warning for each read_epochs_eeglab because both files have epochs # associated with multiple events assert_equal(len(w), 2) assert_array_equal(epochs.get_data(), epochs2.get_data()) # test different combinations of events and event_ids temp_dir = _TempDir() out_fname = op.join(temp_dir, 'test-eve.fif') write_events(out_fname, epochs.events) event_id = {'S255/S8': 1, 'S8': 2, 'S255/S9': 3} epochs = read_epochs_eeglab(epochs_fname, epochs.events, event_id) assert_equal(len(epochs.events), 4) assert_true(epochs.preload) assert_true(epochs._bad_dropped) epochs = read_epochs_eeglab(epochs_fname, out_fname, event_id) assert_raises(ValueError, read_epochs_eeglab, epochs_fname, None, event_id) assert_raises(ValueError, read_epochs_eeglab, epochs_fname, epochs.events, None) # test reading file with one event eeg = io.loadmat(raw_fname, struct_as_record=False, squeeze_me=True)['EEG'] one_event_fname = op.join(temp_dir, 'test_one_event.set') io.savemat(one_event_fname, {'EEG': {'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': eeg.nbchan, 'data': 'test_one_event.fdt', 'epoch': eeg.epoch, 'event': eeg.event[0], 'chanlocs': eeg.chanlocs, 'pnts': eeg.pnts}}) shutil.copyfile(op.join(base_dir, 'test_raw.fdt'), op.join(temp_dir, 'test_one_event.fdt')) event_id = {eeg.event[0].type: 1} read_raw_eeglab(input_fname=one_event_fname, montage=montage, event_id=event_id, preload=True) # test overlapping events overlap_fname = op.join(temp_dir, 'test_overlap_event.set') io.savemat(overlap_fname, {'EEG': {'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': eeg.nbchan, 'data': 'test_overlap_event.fdt', 'epoch': eeg.epoch, 'event': [eeg.event[0], eeg.event[0]], 'chanlocs': eeg.chanlocs, 'pnts': eeg.pnts}}) shutil.copyfile(op.join(base_dir, 'test_raw.fdt'), op.join(temp_dir, 'test_overlap_event.fdt')) event_id = {'rt': 1, 'square': 2} with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') raw = read_raw_eeglab(input_fname=overlap_fname, montage=montage, event_id=event_id, preload=True) assert_equal(len(w), 1) # one warning for the dropped event events_stimchan = find_events(raw) events_read_events_eeglab = read_events_eeglab(overlap_fname, event_id) assert_true(len(events_stimchan) == 1) assert_true(len(events_read_events_eeglab) == 2) # test reading file with one channel one_chan_fname = op.join(temp_dir, 'test_one_channel.set') io.savemat(one_chan_fname, {'EEG': {'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': 1, 'data': np.random.random((1, 3)), 'epoch': eeg.epoch, 'event': eeg.epoch, 'chanlocs': {'labels': 'E1', 'Y': -6.6069, 'X': 6.3023, 'Z': -2.9423}, 'times': eeg.times[:3], 'pnts': 3}}) with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') read_raw_eeglab(input_fname=one_chan_fname, preload=True) # no warning for 'no events found' assert_equal(len(w), 0) # test reading file with 3 channels - one without position information # first, create chanlocs structured array ch_names = ['F3', 'unknown', 'FPz'] x, y, z = [1., 2., np.nan], [4., 5., np.nan], [7., 8., np.nan] dt = [('labels', 'S10'), ('X', 'f8'), ('Y', 'f8'), ('Z', 'f8')] chanlocs = np.zeros((3,), dtype=dt) for ind, vals in enumerate(zip(ch_names, x, y, z)): for fld in range(4): chanlocs[ind][dt[fld][0]] = vals[fld] if LooseVersion(np.__version__) == '1.14.0': # There is a bug in 1.14.0 (or maybe with SciPy 1.0.0?) that causes # this write to fail! raise SkipTest('Need to fix bug in NumPy 1.14.0!') # save set file one_chanpos_fname = op.join(temp_dir, 'test_chanpos.set') io.savemat(one_chanpos_fname, {'EEG': {'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': 3, 'data': np.random.random((3, 3)), 'epoch': eeg.epoch, 'event': eeg.epoch, 'chanlocs': chanlocs, 'times': eeg.times[:3], 'pnts': 3}}) # load it with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') raw = read_raw_eeglab(input_fname=one_chanpos_fname, preload=True) # one warning because some channels are not found in Montage assert_equal(len(w), 1) # position should be present for first two channels for i in range(2): assert_array_equal(raw.info['chs'][i]['loc'][:3], np.array([-chanlocs[i]['Y'], chanlocs[i]['X'], chanlocs[i]['Z']])) # position of the last channel should be zero assert_array_equal(raw.info['chs'][-1]['loc'][:3], [np.nan] * 3) # test reading channel names from set and positions from montage with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') raw = read_raw_eeglab(input_fname=one_chanpos_fname, preload=True, montage=montage) # one warning because some channels are not found in Montage assert_equal(len(w), 1) # when montage was passed - channel positions should be taken from there correct_pos = [[-0.56705965, 0.67706631, 0.46906776], [np.nan] * 3, [0., 0.99977915, -0.02101571]] for ch_ind in range(3): assert_array_almost_equal(raw.info['chs'][ch_ind]['loc'][:3], np.array(correct_pos[ch_ind])) # test reading channel names but not positions when there is no X (only Z) # field in the EEG.chanlocs structure nopos_chanlocs = chanlocs[['labels', 'Z']] nopos_fname = op.join(temp_dir, 'test_no_chanpos.set') io.savemat(nopos_fname, {'EEG': {'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': 3, 'data': np.random.random((3, 2)), 'epoch': eeg.epoch, 'event': eeg.epoch, 'chanlocs': nopos_chanlocs, 'times': eeg.times[:2], 'pnts': 2}}) # load the file with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') raw = read_raw_eeglab(input_fname=nopos_fname, preload=True) # test that channel names have been loaded but not channel positions for i in range(3): assert_equal(raw.info['chs'][i]['ch_name'], ch_names[i]) assert_array_equal(raw.info['chs'][i]['loc'][:3], np.array([0., 0., 0.]))
def test_io_set_raw(fnames, tmpdir): """Test importing EEGLAB .set files.""" tmpdir = str(tmpdir) raw_fname, raw_fname_onefile = fnames with pytest.warns(RuntimeWarning) as w: _test_raw_reader(read_raw_eeglab, input_fname=raw_fname, montage=montage) _test_raw_reader(read_raw_eeglab, input_fname=raw_fname_onefile, montage=montage) for want in ('Events like', 'consist entirely', 'could not be mapped', 'string preload is not supported'): assert (any(want in str(ww.message) for ww in w)) with pytest.warns(RuntimeWarning) as w: # test finding events in continuous data event_id = {'rt': 1, 'square': 2} raw0 = read_raw_eeglab(input_fname=raw_fname, montage=montage, event_id=event_id, preload=True) raw1 = read_raw_eeglab(input_fname=raw_fname, montage=montage, event_id=event_id, preload=False) raw2 = read_raw_eeglab(input_fname=raw_fname_onefile, montage=montage, event_id=event_id) raw3 = read_raw_eeglab(input_fname=raw_fname, montage=montage, event_id=event_id) raw4 = read_raw_eeglab(input_fname=raw_fname, montage=montage) [w.pop(DeprecationWarning) for _ in range(5)] # read_events_eeglab assert raw0.filenames[0].endswith('.fdt') # .set with additional .fdt assert raw2.filenames[0].endswith('.set') # standalone .set Epochs(raw0, find_events(raw0), event_id) epochs = Epochs(raw1, find_events(raw1), event_id) assert len(find_events(raw4)) == 0 # no events without event_id assert epochs["square"].average().nave == 80 # 80 with assert_array_equal(raw0[:][0], raw1[:][0], raw2[:][0], raw3[:][0]) assert_array_equal(raw0[:][-1], raw1[:][-1], raw2[:][-1], raw3[:][-1]) # 1 for preload=False / str with fname_onefile, 3 for dropped events raw0.filter(1, None, l_trans_bandwidth='auto', filter_length='auto', phase='zero') # test that preloading works while 'FutureWarning' in [xx._category_name for xx in w]: w.pop(FutureWarning) while 'ImportWarning' in [xx._category_name for xx in w]: w.pop(ImportWarning) assert len(w) == 4 # check `preload=False` raises RuntimeWarning # test that using uint16_codec does not break stuff raw0 = read_raw_eeglab(input_fname=raw_fname, montage=montage, event_id=event_id, preload=False, uint16_codec='ascii') # test old EEGLAB version event import (read old version) eeg = io.loadmat(raw_fname_mat, struct_as_record=False, squeeze_me=True)['EEG'] for event in eeg.event: # old version allows integer events event.type = 1 assert_equal(read_events_eeglab(eeg)[-1, -1], 1) eeg.event = eeg.event[0] # single event eeg.event.latency = float(eeg.event.latency) - .1 # test rounding assert_equal(read_events_eeglab(eeg)[-1, -1], 1) # test reading file with one event (read old version) eeg = io.loadmat(raw_fname_mat, struct_as_record=False, squeeze_me=True)['EEG'] one_event_fname = op.join(tmpdir, 'test_one_event.set') io.savemat(one_event_fname, {'EEG': {'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': eeg.nbchan, 'data': 'test_one_event.fdt', 'epoch': eeg.epoch, 'event': eeg.event[0], 'chanlocs': eeg.chanlocs, 'pnts': eeg.pnts}}, appendmat=False, oned_as='row') shutil.copyfile(op.join(base_dir, 'test_raw.fdt'), one_event_fname.replace('.set', '.fdt')) event_id = {eeg.event[0].type: 1} test_raw = read_raw_eeglab(input_fname=one_event_fname, montage=montage, event_id=event_id, preload=True) # test that sample indices are read python-wise (zero-based) assert find_events(test_raw)[0, 0] == round(eeg.event[0].latency) - 1 # test negative event latencies negative_latency_fname = op.join(tmpdir, 'test_negative_latency.set') evnts = deepcopy(eeg.event[0]) evnts.latency = 0 io.savemat(negative_latency_fname, {'EEG': {'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': eeg.nbchan, 'data': 'test_one_event.fdt', 'epoch': eeg.epoch, 'event': evnts, 'chanlocs': eeg.chanlocs, 'pnts': eeg.pnts}}, appendmat=False, oned_as='row') shutil.copyfile(op.join(base_dir, 'test_raw.fdt'), negative_latency_fname.replace('.set', '.fdt')) event_id = {eeg.event[0].type: 1} with pytest.warns(RuntimeWarning, match="has a sample index of -1."): read_raw_eeglab(input_fname=negative_latency_fname, preload=True, event_id=event_id, montage=montage) # test overlapping events overlap_fname = op.join(tmpdir, 'test_overlap_event.set') io.savemat(overlap_fname, {'EEG': {'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': eeg.nbchan, 'data': 'test_overlap_event.fdt', 'epoch': eeg.epoch, 'event': [eeg.event[0], eeg.event[0]], 'chanlocs': eeg.chanlocs, 'pnts': eeg.pnts}}, appendmat=False, oned_as='row') shutil.copyfile(op.join(base_dir, 'test_raw.fdt'), overlap_fname.replace('.set', '.fdt')) event_id = {'rt': 1, 'square': 2} with pytest.warns(RuntimeWarning, match='will be dropped'): raw = read_raw_eeglab(input_fname=overlap_fname, montage=montage, event_id=event_id, preload=True) events_stimchan = find_events(raw) events_read_events_eeglab = read_events_eeglab(overlap_fname, event_id) assert (len(events_stimchan) == 1) assert (len(events_read_events_eeglab) == 2) # test reading file with one channel one_chan_fname = op.join(tmpdir, 'test_one_channel.set') io.savemat(one_chan_fname, {'EEG': {'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': 1, 'data': np.random.random((1, 3)), 'epoch': eeg.epoch, 'event': eeg.epoch, 'chanlocs': {'labels': 'E1', 'Y': -6.6069, 'X': 6.3023, 'Z': -2.9423}, 'times': eeg.times[:3], 'pnts': 3}}, appendmat=False, oned_as='row') with pytest.warns(None) as w: read_raw_eeglab(input_fname=one_chan_fname, preload=True) # no warning for 'no events found' w.pop(DeprecationWarning) assert len(w) == 0 # test reading file with 3 channels - one without position information # first, create chanlocs structured array ch_names = ['F3', 'unknown', 'FPz'] x, y, z = [1., 2., np.nan], [4., 5., np.nan], [7., 8., np.nan] dt = [('labels', 'S10'), ('X', 'f8'), ('Y', 'f8'), ('Z', 'f8')] chanlocs = np.zeros((3,), dtype=dt) for ind, vals in enumerate(zip(ch_names, x, y, z)): for fld in range(4): chanlocs[ind][dt[fld][0]] = vals[fld] if LooseVersion(np.__version__) == '1.14.0': # There is a bug in 1.14.0 (or maybe with SciPy 1.0.0?) that causes # this write to fail! raise SkipTest('Need to fix bug in NumPy 1.14.0!') # save set file one_chanpos_fname = op.join(tmpdir, 'test_chanpos.set') io.savemat(one_chanpos_fname, {'EEG': {'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': 3, 'data': np.random.random((3, 3)), 'epoch': eeg.epoch, 'event': eeg.epoch, 'chanlocs': chanlocs, 'times': eeg.times[:3], 'pnts': 3}}, appendmat=False, oned_as='row') # load it with pytest.warns(RuntimeWarning, match='did not have a position'): raw = read_raw_eeglab(input_fname=one_chanpos_fname, preload=True) # position should be present for first two channels for i in range(2): assert_array_equal(raw.info['chs'][i]['loc'][:3], np.array([-chanlocs[i]['Y'], chanlocs[i]['X'], chanlocs[i]['Z']])) # position of the last channel should be zero assert_array_equal(raw.info['chs'][-1]['loc'][:3], [np.nan] * 3) # test reading channel names from set and positions from montage with pytest.warns(RuntimeWarning, match='did not have a position'): raw = read_raw_eeglab(input_fname=one_chanpos_fname, preload=True, montage=montage) # when montage was passed - channel positions should be taken from there correct_pos = [[-0.56705965, 0.67706631, 0.46906776], [np.nan] * 3, [0., 0.99977915, -0.02101571]] for ch_ind in range(3): assert_array_almost_equal(raw.info['chs'][ch_ind]['loc'][:3], np.array(correct_pos[ch_ind])) # test reading channel names but not positions when there is no X (only Z) # field in the EEG.chanlocs structure nopos_chanlocs = chanlocs[['labels', 'Z']] nopos_fname = op.join(tmpdir, 'test_no_chanpos.set') io.savemat(nopos_fname, {'EEG': {'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': 3, 'data': np.random.random((3, 2)), 'epoch': eeg.epoch, 'event': eeg.epoch, 'chanlocs': nopos_chanlocs, 'times': eeg.times[:2], 'pnts': 2}}, appendmat=False, oned_as='row') # load the file raw = read_raw_eeglab(input_fname=nopos_fname, preload=True) # test that channel names have been loaded but not channel positions for i in range(3): assert_equal(raw.info['chs'][i]['ch_name'], ch_names[i]) assert_array_equal(raw.info['chs'][i]['loc'][:3], np.array([np.nan, np.nan, np.nan]))
def test_io_set_raw(fnames, tmpdir): """Test importing EEGLAB .set files.""" tmpdir = str(tmpdir) raw_fname, raw_fname_onefile = fnames _test_raw_reader(read_raw_eeglab, input_fname=raw_fname, montage=montage) # test that preloading works raw0 = read_raw_eeglab(input_fname=raw_fname, montage=montage, preload=True) raw0.filter(1, None, l_trans_bandwidth='auto', filter_length='auto', phase='zero') # test that using uint16_codec does not break stuff raw0 = read_raw_eeglab(input_fname=raw_fname, montage=montage, preload=False, uint16_codec='ascii') # test reading file with one event (read old version) eeg = io.loadmat(raw_fname_mat, struct_as_record=False, squeeze_me=True)['EEG'] # test negative event latencies negative_latency_fname = op.join(tmpdir, 'test_negative_latency.set') evnts = deepcopy(eeg.event[0]) evnts.latency = 0 io.savemat(negative_latency_fname, { 'EEG': { 'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': eeg.nbchan, 'data': 'test_negative_latency.fdt', 'epoch': eeg.epoch, 'event': evnts, 'chanlocs': eeg.chanlocs, 'pnts': eeg.pnts } }, appendmat=False, oned_as='row') shutil.copyfile(op.join(base_dir, 'test_raw.fdt'), negative_latency_fname.replace('.set', '.fdt')) with pytest.warns(RuntimeWarning, match="has a sample index of -1."): read_raw_eeglab(input_fname=negative_latency_fname, preload=True, montage=montage) evnts.latency = -1 io.savemat(negative_latency_fname, { 'EEG': { 'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': eeg.nbchan, 'data': 'test_negative_latency.fdt', 'epoch': eeg.epoch, 'event': evnts, 'chanlocs': eeg.chanlocs, 'pnts': eeg.pnts } }, appendmat=False, oned_as='row') with pytest.raises(ValueError, match='event sample index is negative'): with pytest.warns(RuntimeWarning, match="has a sample index of -1."): read_raw_eeglab(input_fname=negative_latency_fname, preload=True, montage=montage) # test overlapping events overlap_fname = op.join(tmpdir, 'test_overlap_event.set') io.savemat(overlap_fname, { 'EEG': { 'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': eeg.nbchan, 'data': 'test_overlap_event.fdt', 'epoch': eeg.epoch, 'event': [eeg.event[0], eeg.event[0]], 'chanlocs': eeg.chanlocs, 'pnts': eeg.pnts } }, appendmat=False, oned_as='row') shutil.copyfile(op.join(base_dir, 'test_raw.fdt'), overlap_fname.replace('.set', '.fdt')) # test reading file with one channel one_chan_fname = op.join(tmpdir, 'test_one_channel.set') io.savemat(one_chan_fname, { 'EEG': { 'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': 1, 'data': np.random.random((1, 3)), 'epoch': eeg.epoch, 'event': eeg.epoch, 'chanlocs': { 'labels': 'E1', 'Y': -6.6069, 'X': 6.3023, 'Z': -2.9423 }, 'times': eeg.times[:3], 'pnts': 3 } }, appendmat=False, oned_as='row') read_raw_eeglab(input_fname=one_chan_fname, preload=True) # test reading file with 3 channels - one without position information # first, create chanlocs structured array ch_names = ['F3', 'unknown', 'FPz'] x, y, z = [1., 2., np.nan], [4., 5., np.nan], [7., 8., np.nan] dt = [('labels', 'S10'), ('X', 'f8'), ('Y', 'f8'), ('Z', 'f8')] nopos_dt = [('labels', 'S10'), ('Z', 'f8')] chanlocs = np.zeros((3, ), dtype=dt) nopos_chanlocs = np.zeros((3, ), dtype=nopos_dt) for ind, vals in enumerate(zip(ch_names, x, y, z)): for fld in range(4): chanlocs[ind][dt[fld][0]] = vals[fld] if fld in (0, 3): nopos_chanlocs[ind][dt[fld][0]] = vals[fld] # In theory this should work and be simpler, but there is an obscure # SciPy writing bug that pops up sometimes: # nopos_chanlocs = np.array(chanlocs[['labels', 'Z']]) if LooseVersion(np.__version__) == '1.14.0': # There is a bug in 1.14.0 (or maybe with SciPy 1.0.0?) that causes # this write to fail! raise SkipTest('Need to fix bug in NumPy 1.14.0!') # save set file one_chanpos_fname = op.join(tmpdir, 'test_chanpos.set') io.savemat(one_chanpos_fname, { 'EEG': { 'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': 3, 'data': np.random.random((3, 3)), 'epoch': eeg.epoch, 'event': eeg.epoch, 'chanlocs': chanlocs, 'times': eeg.times[:3], 'pnts': 3 } }, appendmat=False, oned_as='row') # load it with pytest.warns(RuntimeWarning, match='did not have a position'): raw = read_raw_eeglab(input_fname=one_chanpos_fname, preload=True) # position should be present for first two channels for i in range(2): assert_array_equal( raw.info['chs'][i]['loc'][:3], np.array([-chanlocs[i]['Y'], chanlocs[i]['X'], chanlocs[i]['Z']])) # position of the last channel should be zero assert_array_equal(raw.info['chs'][-1]['loc'][:3], [np.nan] * 3) # test reading channel names from set and positions from montage with pytest.warns(RuntimeWarning, match='did not have a position'): raw = read_raw_eeglab(input_fname=one_chanpos_fname, preload=True, montage=montage) # when montage was passed - channel positions should be taken from there correct_pos = [[-0.56705965, 0.67706631, 0.46906776], [np.nan] * 3, [0., 0.99977915, -0.02101571]] for ch_ind in range(3): assert_array_almost_equal(raw.info['chs'][ch_ind]['loc'][:3], np.array(correct_pos[ch_ind])) # test reading channel names but not positions when there is no X (only Z) # field in the EEG.chanlocs structure nopos_fname = op.join(tmpdir, 'test_no_chanpos.set') io.savemat(nopos_fname, { 'EEG': { 'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': 3, 'data': np.random.random((3, 2)), 'epoch': eeg.epoch, 'event': eeg.epoch, 'chanlocs': nopos_chanlocs, 'times': eeg.times[:2], 'pnts': 2 } }, appendmat=False, oned_as='row') # load the file raw = read_raw_eeglab(input_fname=nopos_fname, preload=True) # test that channel names have been loaded but not channel positions for i in range(3): assert_equal(raw.info['chs'][i]['ch_name'], ch_names[i]) assert_array_equal(raw.info['chs'][i]['loc'][:3], np.array([np.nan, np.nan, np.nan]))
def test_io_set(): """Test importing EEGLAB .set files""" from scipy import io with warnings.catch_warnings(record=True) as w1: warnings.simplefilter('always') # main tests, and test missing event_id _test_raw_reader(read_raw_eeglab, input_fname=raw_fname, montage=montage) _test_raw_reader(read_raw_eeglab, input_fname=raw_fname_onefile, montage=montage) assert_equal(len(w1), 20) # f3 or preload_false and a lot for dropping events with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') # test finding events in continuous data event_id = {'rt': 1, 'square': 2} raw0 = read_raw_eeglab(input_fname=raw_fname, montage=montage, event_id=event_id, preload=True) raw1 = read_raw_eeglab(input_fname=raw_fname, montage=montage, event_id=event_id, preload=False) raw2 = read_raw_eeglab(input_fname=raw_fname_onefile, montage=montage, event_id=event_id) raw3 = read_raw_eeglab(input_fname=raw_fname, montage=montage, event_id=event_id) raw4 = read_raw_eeglab(input_fname=raw_fname, montage=montage) Epochs(raw0, find_events(raw0), event_id) epochs = Epochs(raw1, find_events(raw1), event_id) assert_equal(len(find_events(raw4)), 0) # no events without event_id assert_equal(epochs["square"].average().nave, 80) # 80 with assert_array_equal(raw0[:][0], raw1[:][0], raw2[:][0], raw3[:][0]) assert_array_equal(raw0[:][-1], raw1[:][-1], raw2[:][-1], raw3[:][-1]) assert_equal(len(w), 4) # 1 for preload=False / str with fname_onefile, 3 for dropped events raw0.filter(1, None) # test that preloading works with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') epochs = read_epochs_eeglab(epochs_fname) epochs2 = read_epochs_eeglab(epochs_fname_onefile) # 3 warnings for each read_epochs_eeglab because there are 3 epochs # associated with multiple events assert_equal(len(w), 6) assert_array_equal(epochs.get_data(), epochs2.get_data()) # test different combinations of events and event_ids temp_dir = _TempDir() out_fname = op.join(temp_dir, 'test-eve.fif') write_events(out_fname, epochs.events) event_id = {'S255/S8': 1, 'S8': 2, 'S255/S9': 3} epochs = read_epochs_eeglab(epochs_fname, epochs.events, event_id) epochs = read_epochs_eeglab(epochs_fname, out_fname, event_id) assert_raises(ValueError, read_epochs_eeglab, epochs_fname, None, event_id) assert_raises(ValueError, read_epochs_eeglab, epochs_fname, epochs.events, None) # test reading file with one event eeg = io.loadmat(raw_fname, struct_as_record=False, squeeze_me=True)['EEG'] one_event_fname = op.join(temp_dir, 'test_one_event.set') io.savemat(one_event_fname, {'EEG': {'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': eeg.nbchan, 'data': 'test_one_event.fdt', 'epoch': eeg.epoch, 'event': eeg.event[0], 'chanlocs': eeg.chanlocs, 'pnts': eeg.pnts}}) shutil.copyfile(op.join(base_dir, 'test_raw.fdt'), op.join(temp_dir, 'test_one_event.fdt')) event_id = {eeg.event[0].type: 1} read_raw_eeglab(input_fname=one_event_fname, montage=montage, event_id=event_id, preload=True) # test if .dat file raises an error eeg = io.loadmat(epochs_fname, struct_as_record=False, squeeze_me=True)['EEG'] eeg.data = 'epochs_fname.dat' bad_epochs_fname = op.join(temp_dir, 'test_epochs.set') io.savemat(bad_epochs_fname, {'EEG': {'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': eeg.nbchan, 'data': eeg.data, 'epoch': eeg.epoch, 'event': eeg.event, 'chanlocs': eeg.chanlocs}}) shutil.copyfile(op.join(base_dir, 'test_epochs.fdt'), op.join(temp_dir, 'test_epochs.dat')) with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') assert_raises(NotImplementedError, read_epochs_eeglab, bad_epochs_fname) assert_equal(len(w), 3)
def test_io_set_raw(fnames, tmpdir): """Test importing EEGLAB .set files.""" tmpdir = str(tmpdir) raw_fname, raw_fname_onefile = fnames _test_raw_reader(read_raw_eeglab, input_fname=raw_fname, montage=montage) # test that preloading works raw0 = read_raw_eeglab(input_fname=raw_fname, montage=montage, preload=True) raw0.filter(1, None, l_trans_bandwidth='auto', filter_length='auto', phase='zero') # test that using uint16_codec does not break stuff raw0 = read_raw_eeglab(input_fname=raw_fname, montage=montage, preload=False, uint16_codec='ascii') # test reading file with one event (read old version) eeg = io.loadmat(raw_fname_mat, struct_as_record=False, squeeze_me=True)['EEG'] # test negative event latencies negative_latency_fname = op.join(tmpdir, 'test_negative_latency.set') evnts = deepcopy(eeg.event[0]) evnts.latency = 0 io.savemat(negative_latency_fname, {'EEG': {'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': eeg.nbchan, 'data': 'test_negative_latency.fdt', 'epoch': eeg.epoch, 'event': evnts, 'chanlocs': eeg.chanlocs, 'pnts': eeg.pnts}}, appendmat=False, oned_as='row') shutil.copyfile(op.join(base_dir, 'test_raw.fdt'), negative_latency_fname.replace('.set', '.fdt')) with pytest.warns(RuntimeWarning, match="has a sample index of -1."): read_raw_eeglab(input_fname=negative_latency_fname, preload=True, montage=montage) evnts.latency = -1 io.savemat(negative_latency_fname, {'EEG': {'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': eeg.nbchan, 'data': 'test_negative_latency.fdt', 'epoch': eeg.epoch, 'event': evnts, 'chanlocs': eeg.chanlocs, 'pnts': eeg.pnts}}, appendmat=False, oned_as='row') with pytest.raises(ValueError, match='event sample index is negative'): with pytest.warns(RuntimeWarning, match="has a sample index of -1."): read_raw_eeglab(input_fname=negative_latency_fname, preload=True, montage=montage) # test overlapping events overlap_fname = op.join(tmpdir, 'test_overlap_event.set') io.savemat(overlap_fname, {'EEG': {'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': eeg.nbchan, 'data': 'test_overlap_event.fdt', 'epoch': eeg.epoch, 'event': [eeg.event[0], eeg.event[0]], 'chanlocs': eeg.chanlocs, 'pnts': eeg.pnts}}, appendmat=False, oned_as='row') shutil.copyfile(op.join(base_dir, 'test_raw.fdt'), overlap_fname.replace('.set', '.fdt')) # test reading file with one channel one_chan_fname = op.join(tmpdir, 'test_one_channel.set') io.savemat(one_chan_fname, {'EEG': {'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': 1, 'data': np.random.random((1, 3)), 'epoch': eeg.epoch, 'event': eeg.epoch, 'chanlocs': {'labels': 'E1', 'Y': -6.6069, 'X': 6.3023, 'Z': -2.9423}, 'times': eeg.times[:3], 'pnts': 3}}, appendmat=False, oned_as='row') with pytest.warns(None) as w: read_raw_eeglab(input_fname=one_chan_fname, preload=True, stim_channel=False) # no warning for 'no events found' assert len(w) == 0 # test reading file with 3 channels - one without position information # first, create chanlocs structured array ch_names = ['F3', 'unknown', 'FPz'] x, y, z = [1., 2., np.nan], [4., 5., np.nan], [7., 8., np.nan] dt = [('labels', 'S10'), ('X', 'f8'), ('Y', 'f8'), ('Z', 'f8')] nopos_dt = [('labels', 'S10'), ('Z', 'f8')] chanlocs = np.zeros((3,), dtype=dt) nopos_chanlocs = np.zeros((3,), dtype=nopos_dt) for ind, vals in enumerate(zip(ch_names, x, y, z)): for fld in range(4): chanlocs[ind][dt[fld][0]] = vals[fld] if fld in (0, 3): nopos_chanlocs[ind][dt[fld][0]] = vals[fld] # In theory this should work and be simpler, but there is an obscure # SciPy writing bug that pops up sometimes: # nopos_chanlocs = np.array(chanlocs[['labels', 'Z']]) if LooseVersion(np.__version__) == '1.14.0': # There is a bug in 1.14.0 (or maybe with SciPy 1.0.0?) that causes # this write to fail! raise SkipTest('Need to fix bug in NumPy 1.14.0!') # save set file one_chanpos_fname = op.join(tmpdir, 'test_chanpos.set') io.savemat(one_chanpos_fname, {'EEG': {'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': 3, 'data': np.random.random((3, 3)), 'epoch': eeg.epoch, 'event': eeg.epoch, 'chanlocs': chanlocs, 'times': eeg.times[:3], 'pnts': 3}}, appendmat=False, oned_as='row') # load it with pytest.warns(RuntimeWarning, match='did not have a position'): raw = read_raw_eeglab(input_fname=one_chanpos_fname, preload=True) # position should be present for first two channels for i in range(2): assert_array_equal(raw.info['chs'][i]['loc'][:3], np.array([-chanlocs[i]['Y'], chanlocs[i]['X'], chanlocs[i]['Z']])) # position of the last channel should be zero assert_array_equal(raw.info['chs'][-1]['loc'][:3], [np.nan] * 3) # test reading channel names from set and positions from montage with pytest.warns(RuntimeWarning, match='did not have a position'): raw = read_raw_eeglab(input_fname=one_chanpos_fname, preload=True, montage=montage) # when montage was passed - channel positions should be taken from there correct_pos = [[-0.56705965, 0.67706631, 0.46906776], [np.nan] * 3, [0., 0.99977915, -0.02101571]] for ch_ind in range(3): assert_array_almost_equal(raw.info['chs'][ch_ind]['loc'][:3], np.array(correct_pos[ch_ind])) # test reading channel names but not positions when there is no X (only Z) # field in the EEG.chanlocs structure nopos_fname = op.join(tmpdir, 'test_no_chanpos.set') io.savemat(nopos_fname, {'EEG': {'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': 3, 'data': np.random.random((3, 2)), 'epoch': eeg.epoch, 'event': eeg.epoch, 'chanlocs': nopos_chanlocs, 'times': eeg.times[:2], 'pnts': 2}}, appendmat=False, oned_as='row') # load the file raw = read_raw_eeglab(input_fname=nopos_fname, preload=True, stim_channel=False) # test that channel names have been loaded but not channel positions for i in range(3): assert_equal(raw.info['chs'][i]['ch_name'], ch_names[i]) assert_array_equal(raw.info['chs'][i]['loc'][:3], np.array([np.nan, np.nan, np.nan]))
def test_io_set(): """Test importing EEGLAB .set files""" from scipy import io with warnings.catch_warnings(record=True) as w1: warnings.simplefilter('always') # main tests, and test missing event_id _test_raw_reader(read_raw_eeglab, input_fname=raw_fname, montage=montage) _test_raw_reader(read_raw_eeglab, input_fname=raw_fname_onefile, montage=montage) assert_equal(len(w1), 20) # f3 or preload_false and a lot for dropping events with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') # test finding events in continuous data event_id = {'rt': 1, 'square': 2} raw0 = read_raw_eeglab(input_fname=raw_fname, montage=montage, event_id=event_id, preload=True) raw1 = read_raw_eeglab(input_fname=raw_fname, montage=montage, event_id=event_id, preload=False) raw2 = read_raw_eeglab(input_fname=raw_fname_onefile, montage=montage, event_id=event_id) raw3 = read_raw_eeglab(input_fname=raw_fname, montage=montage, event_id=event_id) raw4 = read_raw_eeglab(input_fname=raw_fname, montage=montage) Epochs(raw0, find_events(raw0), event_id) epochs = Epochs(raw1, find_events(raw1), event_id) assert_equal(len(find_events(raw4)), 0) # no events without event_id assert_equal(epochs["square"].average().nave, 80) # 80 with assert_array_equal(raw0[:][0], raw1[:][0], raw2[:][0], raw3[:][0]) assert_array_equal(raw0[:][-1], raw1[:][-1], raw2[:][-1], raw3[:][-1]) assert_equal(len(w), 4) # 1 for preload=False / str with fname_onefile, 3 for dropped events raw0.filter(1, None, l_trans_bandwidth='auto', filter_length='auto', phase='zero') # test that preloading works # test that using uin16_codec does not break stuff raw0 = read_raw_eeglab(input_fname=raw_fname, montage=montage, event_id=event_id, preload=False, uint16_codec='ascii') # test old EEGLAB version event import eeg = io.loadmat(raw_fname, struct_as_record=False, squeeze_me=True)['EEG'] for event in eeg.event: # old version allows integer events event.type = 1 assert_equal(_read_eeglab_events(eeg)[-1, -1], 1) eeg.event = eeg.event[0] # single event assert_equal(_read_eeglab_events(eeg)[-1, -1], 1) with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') epochs = read_epochs_eeglab(epochs_fname) epochs2 = read_epochs_eeglab(epochs_fname_onefile) # one warning for each read_epochs_eeglab because both files have epochs # associated with multiple events assert_equal(len(w), 2) assert_array_equal(epochs.get_data(), epochs2.get_data()) # test different combinations of events and event_ids temp_dir = _TempDir() out_fname = op.join(temp_dir, 'test-eve.fif') write_events(out_fname, epochs.events) event_id = {'S255/S8': 1, 'S8': 2, 'S255/S9': 3} epochs = read_epochs_eeglab(epochs_fname, epochs.events, event_id) assert_equal(len(epochs.events), 4) epochs = read_epochs_eeglab(epochs_fname, out_fname, event_id) assert_raises(ValueError, read_epochs_eeglab, epochs_fname, None, event_id) assert_raises(ValueError, read_epochs_eeglab, epochs_fname, epochs.events, None) # test reading file with one event eeg = io.loadmat(raw_fname, struct_as_record=False, squeeze_me=True)['EEG'] one_event_fname = op.join(temp_dir, 'test_one_event.set') io.savemat(one_event_fname, {'EEG': {'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': eeg.nbchan, 'data': 'test_one_event.fdt', 'epoch': eeg.epoch, 'event': eeg.event[0], 'chanlocs': eeg.chanlocs, 'pnts': eeg.pnts}}) shutil.copyfile(op.join(base_dir, 'test_raw.fdt'), op.join(temp_dir, 'test_one_event.fdt')) event_id = {eeg.event[0].type: 1} read_raw_eeglab(input_fname=one_event_fname, montage=montage, event_id=event_id, preload=True) # test reading file with one channel one_chan_fname = op.join(temp_dir, 'test_one_channel.set') io.savemat(one_chan_fname, {'EEG': {'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': 1, 'data': np.random.random((1, 3)), 'epoch': eeg.epoch, 'event': eeg.epoch, 'chanlocs': {'labels': 'E1', 'Y': -6.6069, 'X': 6.3023, 'Z': -2.9423}, 'times': eeg.times[:3], 'pnts': 3}}) with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') read_raw_eeglab(input_fname=one_chan_fname, preload=True) # no warning for 'no events found' assert_equal(len(w), 0) # test if .dat file raises an error eeg = io.loadmat(epochs_fname, struct_as_record=False, squeeze_me=True)['EEG'] eeg.data = 'epochs_fname.dat' bad_epochs_fname = op.join(temp_dir, 'test_epochs.set') io.savemat(bad_epochs_fname, {'EEG': {'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': eeg.nbchan, 'data': eeg.data, 'epoch': eeg.epoch, 'event': eeg.event, 'chanlocs': eeg.chanlocs}}) shutil.copyfile(op.join(base_dir, 'test_epochs.fdt'), op.join(temp_dir, 'test_epochs.dat')) with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') assert_raises(NotImplementedError, read_epochs_eeglab, bad_epochs_fname) assert_equal(len(w), 1)
def test_io_set_raw_more(tmpdir): """Test importing EEGLAB .set files.""" tmpdir = str(tmpdir) eeg = io.loadmat(raw_fname_mat, struct_as_record=False, squeeze_me=True)['EEG'] # test reading file with one event (read old version) negative_latency_fname = op.join(tmpdir, 'test_negative_latency.set') evnts = deepcopy(eeg.event[0]) evnts.latency = 0 io.savemat(negative_latency_fname, { 'EEG': { 'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': eeg.nbchan, 'data': 'test_negative_latency.fdt', 'epoch': eeg.epoch, 'event': evnts, 'chanlocs': eeg.chanlocs, 'pnts': eeg.pnts } }, appendmat=False, oned_as='row') shutil.copyfile(op.join(base_dir, 'test_raw.fdt'), negative_latency_fname.replace('.set', '.fdt')) with pytest.warns(RuntimeWarning, match="has a sample index of -1."): read_raw_eeglab(input_fname=negative_latency_fname, preload=True) # test negative event latencies evnts.latency = -1 io.savemat(negative_latency_fname, { 'EEG': { 'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': eeg.nbchan, 'data': 'test_negative_latency.fdt', 'epoch': eeg.epoch, 'event': evnts, 'chanlocs': eeg.chanlocs, 'pnts': eeg.pnts } }, appendmat=False, oned_as='row') with pytest.raises(ValueError, match='event sample index is negative'): with pytest.warns(RuntimeWarning, match="has a sample index of -1."): read_raw_eeglab(input_fname=negative_latency_fname, preload=True) # test overlapping events overlap_fname = op.join(tmpdir, 'test_overlap_event.set') io.savemat(overlap_fname, { 'EEG': { 'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': eeg.nbchan, 'data': 'test_overlap_event.fdt', 'epoch': eeg.epoch, 'event': [eeg.event[0], eeg.event[0]], 'chanlocs': eeg.chanlocs, 'pnts': eeg.pnts } }, appendmat=False, oned_as='row') shutil.copyfile(op.join(base_dir, 'test_raw.fdt'), overlap_fname.replace('.set', '.fdt')) read_raw_eeglab(input_fname=overlap_fname, preload=True) # test reading file when the EEG.data name is wrong io.savemat(overlap_fname, { 'EEG': { 'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': eeg.nbchan, 'data': 'test_overla_event.fdt', 'epoch': eeg.epoch, 'event': [eeg.event[0], eeg.event[0]], 'chanlocs': eeg.chanlocs, 'pnts': eeg.pnts } }, appendmat=False, oned_as='row') with pytest.warns(RuntimeWarning, match="must have changed on disk"): read_raw_eeglab(input_fname=overlap_fname, preload=True) # raise error when both EEG.data and fdt name from set are wrong overlap_fname = op.join(tmpdir, 'test_ovrlap_event.set') io.savemat(overlap_fname, { 'EEG': { 'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': eeg.nbchan, 'data': 'test_overla_event.fdt', 'epoch': eeg.epoch, 'event': [eeg.event[0], eeg.event[0]], 'chanlocs': eeg.chanlocs, 'pnts': eeg.pnts } }, appendmat=False, oned_as='row') with pytest.raises(FileNotFoundError, match="not find the .fdt data file"): read_raw_eeglab(input_fname=overlap_fname, preload=True) # test reading file with one channel one_chan_fname = op.join(tmpdir, 'test_one_channel.set') io.savemat(one_chan_fname, { 'EEG': { 'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': 1, 'data': np.random.random((1, 3)), 'epoch': eeg.epoch, 'event': eeg.epoch, 'chanlocs': { 'labels': 'E1', 'Y': -6.6069, 'X': 6.3023, 'Z': -2.9423 }, 'times': eeg.times[:3], 'pnts': 3 } }, appendmat=False, oned_as='row') read_raw_eeglab(input_fname=one_chan_fname, preload=True) # test reading file with 3 channels - one without position information # first, create chanlocs structured array ch_names = ['F3', 'unknown', 'FPz'] x, y, z = [1., 2., np.nan], [4., 5., np.nan], [7., 8., np.nan] dt = [('labels', 'S10'), ('X', 'f8'), ('Y', 'f8'), ('Z', 'f8')] nopos_dt = [('labels', 'S10'), ('Z', 'f8')] chanlocs = np.zeros((3, ), dtype=dt) nopos_chanlocs = np.zeros((3, ), dtype=nopos_dt) for ind, vals in enumerate(zip(ch_names, x, y, z)): for fld in range(4): chanlocs[ind][dt[fld][0]] = vals[fld] if fld in (0, 3): nopos_chanlocs[ind][dt[fld][0]] = vals[fld] # In theory this should work and be simpler, but there is an obscure # SciPy writing bug that pops up sometimes: # nopos_chanlocs = np.array(chanlocs[['labels', 'Z']]) if LooseVersion(np.__version__) == '1.14.0': # There is a bug in 1.14.0 (or maybe with SciPy 1.0.0?) that causes # this write to fail! raise SkipTest('Need to fix bug in NumPy 1.14.0!') # test reading channel names but not positions when there is no X (only Z) # field in the EEG.chanlocs structure nopos_fname = op.join(tmpdir, 'test_no_chanpos.set') io.savemat(nopos_fname, { 'EEG': { 'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': 3, 'data': np.random.random((3, 2)), 'epoch': eeg.epoch, 'event': eeg.epoch, 'chanlocs': nopos_chanlocs, 'times': eeg.times[:2], 'pnts': 2 } }, appendmat=False, oned_as='row') # load the file raw = read_raw_eeglab(input_fname=nopos_fname, preload=True) # test that channel names have been loaded but not channel positions for i in range(3): assert_equal(raw.info['chs'][i]['ch_name'], ch_names[i]) assert_array_equal(raw.info['chs'][i]['loc'][:3], np.array([np.nan, np.nan, np.nan]))
def test_io_set(): """Test importing EEGLAB .set files""" from scipy import io with warnings.catch_warnings(record=True) as w1: warnings.simplefilter("always") # main tests, and test missing event_id _test_raw_reader(read_raw_eeglab, input_fname=raw_fname, montage=montage) _test_raw_reader(read_raw_eeglab, input_fname=raw_fname_onefile, montage=montage) assert_equal(len(w1), 20) # f3 or preload_false and a lot for dropping events with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") # test finding events in continuous data event_id = {"rt": 1, "square": 2} raw0 = read_raw_eeglab(input_fname=raw_fname, montage=montage, event_id=event_id, preload=True) raw1 = read_raw_eeglab(input_fname=raw_fname, montage=montage, event_id=event_id, preload=False) raw2 = read_raw_eeglab(input_fname=raw_fname_onefile, montage=montage, event_id=event_id) raw3 = read_raw_eeglab(input_fname=raw_fname, montage=montage, event_id=event_id) raw4 = read_raw_eeglab(input_fname=raw_fname, montage=montage) Epochs(raw0, find_events(raw0), event_id) epochs = Epochs(raw1, find_events(raw1), event_id) assert_equal(len(find_events(raw4)), 0) # no events without event_id assert_equal(epochs["square"].average().nave, 80) # 80 with assert_array_equal(raw0[:][0], raw1[:][0], raw2[:][0], raw3[:][0]) assert_array_equal(raw0[:][-1], raw1[:][-1], raw2[:][-1], raw3[:][-1]) assert_equal(len(w), 4) # 1 for preload=False / str with fname_onefile, 3 for dropped events raw0.filter(1, None, l_trans_bandwidth="auto", filter_length="auto", phase="zero") # test that preloading works # test that using uint16_codec does not break stuff raw0 = read_raw_eeglab( input_fname=raw_fname, montage=montage, event_id=event_id, preload=False, uint16_codec="ascii" ) # test old EEGLAB version event import eeg = io.loadmat(raw_fname, struct_as_record=False, squeeze_me=True)["EEG"] for event in eeg.event: # old version allows integer events event.type = 1 assert_equal(_read_eeglab_events(eeg)[-1, -1], 1) eeg.event = eeg.event[0] # single event assert_equal(_read_eeglab_events(eeg)[-1, -1], 1) with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") epochs = read_epochs_eeglab(epochs_fname) epochs2 = read_epochs_eeglab(epochs_fname_onefile) # one warning for each read_epochs_eeglab because both files have epochs # associated with multiple events assert_equal(len(w), 2) assert_array_equal(epochs.get_data(), epochs2.get_data()) # test different combinations of events and event_ids temp_dir = _TempDir() out_fname = op.join(temp_dir, "test-eve.fif") write_events(out_fname, epochs.events) event_id = {"S255/S8": 1, "S8": 2, "S255/S9": 3} epochs = read_epochs_eeglab(epochs_fname, epochs.events, event_id) assert_equal(len(epochs.events), 4) assert_true(epochs.preload) assert_true(epochs._bad_dropped) epochs = read_epochs_eeglab(epochs_fname, out_fname, event_id) assert_raises(ValueError, read_epochs_eeglab, epochs_fname, None, event_id) assert_raises(ValueError, read_epochs_eeglab, epochs_fname, epochs.events, None) # test reading file with one event eeg = io.loadmat(raw_fname, struct_as_record=False, squeeze_me=True)["EEG"] one_event_fname = op.join(temp_dir, "test_one_event.set") io.savemat( one_event_fname, { "EEG": { "trials": eeg.trials, "srate": eeg.srate, "nbchan": eeg.nbchan, "data": "test_one_event.fdt", "epoch": eeg.epoch, "event": eeg.event[0], "chanlocs": eeg.chanlocs, "pnts": eeg.pnts, } }, ) shutil.copyfile(op.join(base_dir, "test_raw.fdt"), op.join(temp_dir, "test_one_event.fdt")) event_id = {eeg.event[0].type: 1} read_raw_eeglab(input_fname=one_event_fname, montage=montage, event_id=event_id, preload=True) # test reading file with one channel one_chan_fname = op.join(temp_dir, "test_one_channel.set") io.savemat( one_chan_fname, { "EEG": { "trials": eeg.trials, "srate": eeg.srate, "nbchan": 1, "data": np.random.random((1, 3)), "epoch": eeg.epoch, "event": eeg.epoch, "chanlocs": {"labels": "E1", "Y": -6.6069, "X": 6.3023, "Z": -2.9423}, "times": eeg.times[:3], "pnts": 3, } }, ) with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") read_raw_eeglab(input_fname=one_chan_fname, preload=True) # no warning for 'no events found' assert_equal(len(w), 0) # test if .dat file raises an error eeg = io.loadmat(epochs_fname, struct_as_record=False, squeeze_me=True)["EEG"] eeg.data = "epochs_fname.dat" bad_epochs_fname = op.join(temp_dir, "test_epochs.set") io.savemat( bad_epochs_fname, { "EEG": { "trials": eeg.trials, "srate": eeg.srate, "nbchan": eeg.nbchan, "data": eeg.data, "epoch": eeg.epoch, "event": eeg.event, "chanlocs": eeg.chanlocs, } }, ) shutil.copyfile(op.join(base_dir, "test_epochs.fdt"), op.join(temp_dir, "test_epochs.dat")) with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") assert_raises(NotImplementedError, read_epochs_eeglab, bad_epochs_fname) assert_equal(len(w), 1)