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 load_openBCI_csv_as_raw(
filename,
sfreq=256.,
ch_ind=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
stim_ind=16,
replace_ch_names=None,
verbose=1):
"""Load CSV files into a Raw object.
Args:
filename (str or list): path or paths to CSV files to load
Keyword Args:
subject_nb (int or str): subject number. If 'all', load all
subjects.
session_nb (int or str): session number. If 'all', load all
sessions.
sfreq (float): EEG sampling frequency
ch_ind (list): indices of the EEG channels to keep
stim_ind (int): index of the stim channel
replace_ch_names (dict or None): dictionary containing a mapping to
rename channels. Useful when an external electrode was used.
Returns:
(mne.io.array.array.RawArray): loaded EEG
"""
n_channel = len(ch_ind)
raw = []
for fname in filename:
# read the file
data = pd.read_csv(fname, index_col=0)
# name of each channels
ch_names = list(data.columns)[0:n_channel] + ['Stim']
if replace_ch_names is not None:
ch_names = [
c if c not in replace_ch_names.keys() else replace_ch_names[c]
for c in ch_names
]
# type of each channels
ch_types = ['eeg'] * n_channel + ['stim']
montage = read_custom_montage('standard_1005')
# get data and exclude Aux channel
data = data.values[:, ch_ind + [stim_ind]].T
# convert in Volts (from uVolts)
data[:-1] *= 1e-6
# create MNE object
info = create_info(ch_names=ch_names,
ch_types=ch_types,
sfreq=sfreq,
montage=montage,
verbose=verbose)
raw.append(RawArray(data=data, info=info, verbose=verbose))
print(raw)
# concatenate all raw objects
raws = concatenate_raws(raw, verbose=verbose)
return raws
def test_read_locs():
"""Test reading EEGLAB locs."""
data = read_custom_montage(locs_montage_fname)._get_ch_pos()
assert_allclose(
actual=np.stack([data[kk]
for kk in ('FPz', 'EOG1', 'F3', 'Fz')] # 4 random chs
),
desired=[[0., 0.094979, -0.001996], [0.02933, 0.069097, -0.058226],
[-0.053871, 0.064321, 0.044561], [0., 0.067885, 0.066458]],
atol=1e-6)
def test_io_set_raw(fname):
"""Test importing EEGLAB .set files."""
montage = read_custom_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 set_raw_montage_from_locs(raw: Raw,
path_to_locs: str,
show_montage: False = bool) -> Raw:
"""
Reads channels locations from a file and applies them to Raw instance.
Parameters
----------
raw: the Raw instance with missing channel locations
path_to_locs: the full path to the channel locations file
(e.g. Starstim20.locs)
show_montage: whether to show channel locations in a plot
Returns
-------
Raw instance
"""
if Path(path_to_locs).exists():
montage = read_custom_montage(path_to_locs)
# check if there are any channels not in raw instance
missing_channel_locations = [
ch_name for ch_name in raw.ch_names
if ch_name not in montage.ch_names
]
if missing_channel_locations:
logger.info(f"There are {len(missing_channel_locations)} channel "
f"positions not present in the "
f"{Path(path_to_locs).stem} file.")
logger.info(f"Assuming these ({missing_channel_locations}) "
f"are not EEG channels, dropping them from Raw.")
raw.drop_channels(missing_channel_locations)
logger.info("Applying channel locations to Raw instance.")
raw.set_montage(montage)
if show_montage:
raw.plot_sensors(show_names=True)
else:
logger.warning(f"Montage file {path_to_locs} path does not exist! "
f"Returning unmodified raw.")
return raw
# Derivatives directory
deriv_dir = data_dir / 'derivatives' / f'task-{task}'
deriv_dir.mkdir(parents=True, exist_ok=True)
# Analysis Directory
analysis_dir = data_dir / 'analyses' / f'task-{task}'
analysis_dir.mkdir(parents=True, exist_ok=True)
# Report directory
report_dir = deriv_dir / 'reports'
report_dir.mkdir(parents=True, exist_ok=True)
# BVEF File
bvef_file = Path('..') / 'brainvision_64.bvef'
bv_montage = read_custom_montage(bvef_file, head_size=.08)
# Define event dictionary
event_dict = {
'bot/stan/a1': 10,
'bot/stan/a2': 11,
'bot/stan/a3': 12,
'bot/stan/a4': 13,
'bot/stan/a5': 14,
'bot/stan/a6': 15,
'bot/stan/a7': 16,
'bot/stan/a8': 17,
'bot/odd/a1': 20,
'bot/odd/a2': 21,
'bot/odd/a3': 22,
'bot/odd/a4': 23,
# FreeSurfer surface RAS (called "mri" in MNE) coordinates using the # transformations that FreeSurfer computes during reconstruction. # ``nibabel`` calls this transformation the ``vox2ras_tkr`` transform # and operates in millimeters, so we can load it, convert it to meters, # and then apply it:: # # >>> pos_vox = ... # loaded from a file somehow # >>> img = nibabel.load(fname_T1) # >>> vox2mri_t = img.header.get_vox2ras_tkr() # voxel -> mri trans # >>> pos_mri = mne.transforms.apply_trans(vox2mri_t, pos_vox) # >>> pos_mri /= 1000. # mm -> m # # You can also verify that these are correct (or manually convert voxels # to MRI coords) by looking at the points in Freeview or tkmedit. dig_montage = read_custom_montage(fname_mon, head_size=None, coord_frame='mri') dig_montage.plot() ############################################################################## # We can then get our transformation from the MRI coordinate frame (where our # points are defined) to the head coordinate frame from the object. trans = compute_native_head_t(dig_montage) print(trans) # should be mri->head, as the "native" space here is MRI ############################################################################## # Let's apply this digitization to our dataset, and in the process # automatically convert our locations to the head coordinate frame, as # shown by :meth:`~mne.io.Raw.plot_sensors`. raw = mne.io.read_raw_fif(fname_raw)
#eegData = eegData[:, eegStartIndex:eegStartIndex+4000]
#eegData = eeg.fillExcludedChannels(eegData, excludedChannels[0, 0])
nElectrodes = eegData.shape[0]
fs = 1000
frameSize = 2000
downsampleFactor = 8
eegData = scipy.signal.decimate(eegData, downsampleFactor)
fs = fs / downsampleFactor
frameSize = int(frameSize / downsampleFactor)
eegDataSplit = eeg.eegSplit(eegData, frameSize)
thresholds = [12500]
montage = channels.read_custom_montage(electrodeLocationsPath)
eegInfo = mne.create_info(montage.ch_names, fs, "eeg")
raw = io.RawArray(eegData * 0.000001, eegInfo, 0)
raw.set_montage(montage)
# raw.filter(1, 40)
# ica = mne.preprocessing.ICA(n_components=20, random_state=97, max_iter=800)
# ica.fit(raw)
# ica.plot_properties(raw)
#print(montage)
#viz.plot_montage(montage)
for t in thresholds:
print("Current Thresh: " + str(t))
for i in range(0, nFrames):
print("Current frame: " + str(i))
def read_brainvision(fname, apply_montage=True, preload=False):
"""Load brainvision data. If apply_montage=True, load and apply the standard
montage for the 64-channel acticap. If add_ref=True add a reference
channel with all zeros"""
raw = read_raw_brainvision(fname, preload=preload)
if apply_montage:
mapping = {
"1": "Fp1",
"2": "Fp2",
"3": "F7",
"4": "F3",
"5": "Fz",
"6": "F4",
"7": "F8",
"8": "FC5",
"9": "FC1",
"10": "FC2",
"11": "FC6",
"12": "T7",
"13": "C3",
"14": "Cz",
"15": "C4",
"16": "T8",
"17": "TP9",
"18": "CP5",
"19": "CP1",
"20": "CP2",
"21": "CP6",
"22": "TP10",
"23": "P7",
"24": "P3",
"25": "Pz",
"26": "P4",
"27": "P8",
"28": "PO9",
"29": "O1",
"30": "Oz",
"31": "O2",
"32": "PO10",
"33": "AF7",
"34": "AF3",
"35": "AF4",
"36": "AF8",
"37": "F5",
"38": "F1",
"39": "F2",
"40": "F6",
"41": "FT9",
"42": "FT7",
"43": "FC3",
"44": "FC4",
"45": "FT8",
"46": "FT10",
"47": "C5",
"48": "C1",
"49": "C2",
"50": "C6",
"51": "TP7",
"52": "CP3",
"53": "CPz",
"54": "CP4",
"55": "TP8",
"56": "P5",
"57": "P1",
"58": "P2",
"59": "P6",
"60": "PO7",
"61": "PO3",
"62": "POz",
"63": "PO4",
"64": "PO8"
}
raw.rename_channels(mapping)
montage = read_custom_montage(
Path(os.environ["EXPDIR"]) / Path("AS-96_REF.bvef"))
raw.set_montage(montage)
return raw
#Loading freesurfer samples data_path = mne.datasets.sample.data_path() subjects_dir = op.join(data_path, 'subjects') fname_raw = op.join(data_path, 'MEG', 'sample', 'sample_audvis_raw.fif') bem_dir = op.join(subjects_dir, 'sample', 'bem') fname_bem = op.join(bem_dir, 'sample-5120-5120-5120-bem-sol.fif') fname_src = op.join(bem_dir, 'sample-oct-6-src.fif') #Loading channel channel_dir='channel location pathway' #Loading custom montage directory and creating montage fname_montage_custom='.loc file of channel locations (from eeglab)' dig_montage = read_custom_montage(fname_montage_custom, head_size=0.095, coord_frame='mri') #Plotting Montage to check for placement dig_montage.plot() fig = dig_montage.plot(kind='3d') fig.gca().view_init(azim=70, elev=15) #dig_montage.plot(kind='topomap', show_names=False) #Matrix of head configuration of montage trans = compute_native_head_t(dig_montage) #Defining channel information channel_names = ['AFz','C3','C4','CPz','Cz','F3','F4','F7','F8','FC1','FC2','FC5','FC6','Fp1','Fp2','FT9','FT10','Fz','T7','T8'] n_channels = 20 channel_types=['eeg']*20 sampling_rate = 1000
"""Test reading BESA fileformats."""
import inspect
import pytest
from pathlib import Path
from mne.io import read_evoked_besa
from mne.channels import read_custom_montage
FILE = Path(inspect.getfile(inspect.currentframe()))
data_dir = FILE.parent / 'data'
avr_file = data_dir / 'simulation.avr'
avr_file_oldstyle = data_dir / 'simulation_oldstyle.avr'
mul_file = data_dir / 'simulation.mul'
montage = read_custom_montage(data_dir / 'simulation.elp')
@pytest.mark.filterwarnings("ignore:Fiducial point nasion not found")
@pytest.mark.parametrize('fname', (avr_file, avr_file_oldstyle, mul_file))
def test_read_evoked_besa(fname):
"""Test reading MESA .avr and .mul files."""
ev = read_evoked_besa(fname)
assert len(ev.ch_names) == len(ev.data) == 33
assert ev.info['sfreq'] == 200
assert ev.tmin == -0.1
assert len(ev.times) == 200
assert ev.ch_names == montage.ch_names
assert ev.comment == 'simulation'
def test_read_evoked_besa_avr_incomplete(tmp_path):
"""Test reading incomplete BESA .avr files."""
