def test_source_space_from_label(): """Test generating a source space from volume label.""" tempdir = _TempDir() aseg_fname = op.join(subjects_dir, 'sample', 'mri', 'aseg.mgz') label_names = get_volume_labels_from_aseg(aseg_fname) volume_label = label_names[int(np.random.rand() * len(label_names))] # Test pos as dict pos = dict() pytest.raises(ValueError, setup_volume_source_space, 'sample', pos=pos, volume_label=volume_label, mri=aseg_fname) # Test no mri provided pytest.raises(RuntimeError, setup_volume_source_space, 'sample', mri=None, volume_label=volume_label) # Test invalid volume label pytest.raises(ValueError, setup_volume_source_space, 'sample', volume_label='Hello World!', mri=aseg_fname) src = setup_volume_source_space('sample', subjects_dir=subjects_dir, volume_label=volume_label, mri=aseg_fname, add_interpolator=False) assert_equal(volume_label, src[0]['seg_name']) # test reading and writing out_name = op.join(tempdir, 'temp-src.fif') write_source_spaces(out_name, src) src_from_file = read_source_spaces(out_name) _compare_source_spaces(src, src_from_file, mode='approx')
def test_write_source_space(): """Test writing and reading of source spaces """ src0 = read_source_spaces(fname, add_geom=False) write_source_spaces(op.join(tempdir, 'tmp.fif'), src0) src1 = read_source_spaces(op.join(tempdir, 'tmp.fif'), add_geom=False) _compare_source_spaces(src0, src1)
def process_subject_source_space(subject): # make BEMs using watershed bem # NOTE: Use MNE version >= 20 or set overwrite=True! # mne.bem.make_watershed_bem(subject, # subjects_dir=subjects_dir, # show=False, # verbose=False, # overwrite=True) bem_surf_fname = op.join(subjects_dir, subject, 'bem', f'{subject}-ico{bem_ico}-bem.fif') bem_sol_fname = op.join(subjects_dir, subject, 'bem', f'{subject}-ico{bem_ico}-bem-sol.fif') src_fname = op.join(subjects_dir, subject, 'bem', f'{subject}-ico{bem_ico}-src.fif') # make BEM models # ico5 is for downsamping bem_surf = mne.make_bem_model( subject, ico=bem_ico, conductivity=[0.3], # for MEG data, 1 layer model is enough subjects_dir=subjects_dir) mne.write_bem_surfaces(bem_surf_fname, bem_surf) # make BEM solution bem_sol = mne.make_bem_solution(bem_surf) mne.write_bem_solution(bem_sol_fname, bem_sol) # Create the surface source space src = mne.setup_source_space(subject, spacing, subjects_dir=subjects_dir) mne.write_source_spaces(src_fname, src, overwrite=True)
def run_forward(subject_id): subject = "sub%03d" % subject_id print("processing subject: %s" % subject) data_path = op.join(meg_dir, subject) fname_ave = op.join(data_path, '%s-ave.fif' % subject) fname_fwd = op.join(data_path, '%s-meg-%s-fwd.fif' % (subject, spacing)) fname_trans = op.join(study_path, 'ds117', subject, 'MEG', '%s-trans.fif' % subject) src = mne.setup_source_space(subject, spacing=spacing, subjects_dir=subjects_dir, overwrite=True, n_jobs=1, add_dist=False) src_fname = op.join(subjects_dir, subject, '%s-src.fif' % spacing) mne.write_source_spaces(src_fname, src) bem_model = mne.make_bem_model(subject, ico=4, subjects_dir=subjects_dir, conductivity=(0.3,)) bem = mne.make_bem_solution(bem_model) info = mne.read_evokeds(fname_ave, condition=0).info fwd = mne.make_forward_solution(info, trans=fname_trans, src=src, bem=bem, fname=None, meg=True, eeg=False, mindist=mindist, n_jobs=1, overwrite=True) fwd = mne.convert_forward_solution(fwd, surf_ori=True) mne.write_forward_solution(fname_fwd, fwd, overwrite=True)
def test_discrete_source_space(tmpdir): """Test setting up (and reading/writing) discrete source spaces.""" src = read_source_spaces(fname) v = src[0]['vertno'] # let's make a discrete version with the C code, and with ours temp_name = tmpdir.join('temp-src.fif') # save temp_pos = tmpdir.join('temp-pos.txt') np.savetxt(str(temp_pos), np.c_[src[0]['rr'][v], src[0]['nn'][v]]) # let's try the spherical one (no bem or surf supplied) run_subprocess(['mne_volume_source_space', '--meters', '--pos', temp_pos, '--src', temp_name]) src_c = read_source_spaces(temp_name) pos_dict = dict(rr=src[0]['rr'][v], nn=src[0]['nn'][v]) src_new = setup_volume_source_space(pos=pos_dict) assert src_new.kind == 'discrete' _compare_source_spaces(src_c, src_new, mode='approx') assert_allclose(src[0]['rr'][v], src_new[0]['rr'], rtol=1e-3, atol=1e-6) assert_allclose(src[0]['nn'][v], src_new[0]['nn'], rtol=1e-3, atol=1e-6) # now do writing write_source_spaces(temp_name, src_c, overwrite=True) src_c2 = read_source_spaces(temp_name) _compare_source_spaces(src_c, src_c2) # now do MRI pytest.raises(ValueError, setup_volume_source_space, 'sample', pos=pos_dict, mri=fname_mri) assert repr(src_new) == repr(src_c) assert src_new.kind == 'discrete' assert _get_src_type(src_new, None) == 'discrete'
def _get_bf_data(save_fieldtrip=False): raw, epochs, evoked, data_cov, _, _, _, _, _, fwd = _get_data(proj=False) if save_fieldtrip is True: # raw needs to be saved with all channels and picked in FieldTrip raw.save(op.join(ft_data_path, 'raw.fif'), overwrite=True) # src (tris are not available in fwd['src'] once imported into MATLAB) src = fwd['src'].copy() mne.write_source_spaces(op.join(ft_data_path, 'src.fif'), src) # pick gradiometers only: epochs.pick_types(meg='grad') evoked.pick_types(meg='grad') # compute covariance matrix data_cov = mne.compute_covariance(epochs, tmin=0.04, tmax=0.145, method='empirical') if save_fieldtrip is True: # if the covariance matrix and epochs need resaving: # data covariance: cov_savepath = op.join(ft_data_path, 'sample_cov') sample_cov = {'sample_cov': data_cov['data']} savemat(cov_savepath, sample_cov) # evoked data: ev_savepath = op.join(ft_data_path, 'sample_evoked') data_ev = {'sample_evoked': evoked.data} savemat(ev_savepath, data_ev) return evoked, data_cov, fwd
def test_add_source_space_distances_limited(): """Test adding distances to source space with a dist_limit.""" tempdir = _TempDir() src = read_source_spaces(fname) src_new = read_source_spaces(fname) del src_new[0]['dist'] del src_new[1]['dist'] n_do = 200 # limit this for speed src_new[0]['vertno'] = src_new[0]['vertno'][:n_do].copy() src_new[1]['vertno'] = src_new[1]['vertno'][:n_do].copy() out_name = op.join(tempdir, 'temp-src.fif') try: add_source_space_distances(src_new, dist_limit=0.007) except RuntimeError: # what we throw when scipy version is wrong raise SkipTest('dist_limit requires scipy > 0.13') write_source_spaces(out_name, src_new) src_new = read_source_spaces(out_name) for so, sn in zip(src, src_new): assert_array_equal(so['dist_limit'], np.array([-0.007], np.float32)) assert_array_equal(sn['dist_limit'], np.array([0.007], np.float32)) do = so['dist'] dn = sn['dist'] # clean out distances > 0.007 in C code do.data[do.data > 0.007] = 0 do.eliminate_zeros() # make sure we have some comparable distances assert np.sum(do.data < 0.007) > 400 # do comparison over the region computed d = (do - dn)[:sn['vertno'][n_do - 1]][:, :sn['vertno'][n_do - 1]] assert_allclose(np.zeros_like(d.data), d.data, rtol=0, atol=1e-6)
def _mne_source_space(subject, src_tag, subjects_dir): """Load mne source space Parameters ---------- subject : str Subejct src_tag : str Spacing (e.g., 'ico-4'). """ src_file = os.path.join(subjects_dir, subject, 'bem', '%s-%s-src.fif' % (subject, src_tag)) src, spacing = src_tag.split('-') if os.path.exists(src_file): return mne.read_source_spaces(src_file, False) elif src == 'ico': ss = mne.setup_source_space(subject, spacing=src + spacing, subjects_dir=subjects_dir, add_dist=True) elif src == 'vol': mri_file = os.path.join(subjects_dir, subject, 'mri', 'orig.mgz') bem_file = os.path.join(subjects_dir, subject, 'bem', 'sample-5120-5120-5120-bem-sol.fif') ss = mne.setup_volume_source_space(subject, pos=float(spacing), mri=mri_file, bem=bem_file, mindist=0., exclude=0., subjects_dir=subjects_dir) else: raise ValueError("src_tag=%s" % repr(src_tag)) mne.write_source_spaces(src_file, ss) return ss
def test_discrete_source_space(): """Test setting up (and reading/writing) discrete source spaces """ src = read_source_spaces(fname) v = src[0]["vertno"] # let's make a discrete version with the C code, and with ours temp_name = op.join(tempdir, "temp-src.fif") try: # save temp_pos = op.join(tempdir, "temp-pos.txt") np.savetxt(temp_pos, np.c_[src[0]["rr"][v], src[0]["nn"][v]]) # let's try the spherical one (no bem or surf supplied) run_subprocess(["mne_volume_source_space", "--meters", "--pos", temp_pos, "--src", temp_name]) src_c = read_source_spaces(temp_name) pos_dict = dict(rr=src[0]["rr"][v], nn=src[0]["nn"][v]) src_new = setup_volume_source_space("sample", None, pos=pos_dict, subjects_dir=subjects_dir) _compare_source_spaces(src_c, src_new, mode="approx") assert_allclose(src[0]["rr"][v], src_new[0]["rr"], rtol=1e-3, atol=1e-6) assert_allclose(src[0]["nn"][v], src_new[0]["nn"], rtol=1e-3, atol=1e-6) # now do writing write_source_spaces(temp_name, src_c) src_c2 = read_source_spaces(temp_name) _compare_source_spaces(src_c, src_c2) # now do MRI assert_raises(ValueError, setup_volume_source_space, "sample", pos=pos_dict, mri=fname_mri) finally: if op.isfile(temp_name): os.remove(temp_name)
def test_volume_source_space(): """Test setting up volume source spaces.""" tempdir = _TempDir() src = read_source_spaces(fname_vol) temp_name = op.join(tempdir, 'temp-src.fif') surf = read_bem_surfaces(fname_bem, s_id=FIFF.FIFFV_BEM_SURF_ID_BRAIN) surf['rr'] *= 1e3 # convert to mm # The one in the testing dataset (uses bem as bounds) for bem, surf in zip((fname_bem, None), (None, surf)): src_new = setup_volume_source_space( 'sample', pos=7.0, bem=bem, surface=surf, mri='T1.mgz', subjects_dir=subjects_dir) write_source_spaces(temp_name, src_new, overwrite=True) src[0]['subject_his_id'] = 'sample' # XXX: to make comparison pass _compare_source_spaces(src, src_new, mode='approx') del src_new src_new = read_source_spaces(temp_name) _compare_source_spaces(src, src_new, mode='approx') pytest.raises(IOError, setup_volume_source_space, 'sample', pos=7.0, bem=None, surface='foo', # bad surf mri=fname_mri, subjects_dir=subjects_dir) assert repr(src) == repr(src_new) assert src.kind == 'volume' # Spheres sphere = make_sphere_model(r0=(0., 0., 0.), head_radius=0.1, relative_radii=(0.9, 1.0), sigmas=(0.33, 1.0)) src = setup_volume_source_space(pos=10) src_new = setup_volume_source_space(pos=10, sphere=sphere) _compare_source_spaces(src, src_new, mode='exact') pytest.raises(ValueError, setup_volume_source_space, sphere='foo') # Need a radius sphere = make_sphere_model(head_radius=None) pytest.raises(ValueError, setup_volume_source_space, sphere=sphere)
def test_add_source_space_distances_limited(tmpdir): """Test adding distances to source space with a dist_limit.""" src = read_source_spaces(fname) src_new = read_source_spaces(fname) del src_new[0]['dist'] del src_new[1]['dist'] n_do = 200 # limit this for speed src_new[0]['vertno'] = src_new[0]['vertno'][:n_do].copy() src_new[1]['vertno'] = src_new[1]['vertno'][:n_do].copy() out_name = tmpdir.join('temp-src.fif') add_source_space_distances(src_new, dist_limit=0.007) write_source_spaces(out_name, src_new) src_new = read_source_spaces(out_name) for so, sn in zip(src, src_new): assert_array_equal(so['dist_limit'], np.array([-0.007], np.float32)) assert_array_equal(sn['dist_limit'], np.array([0.007], np.float32)) do = so['dist'] dn = sn['dist'] # clean out distances > 0.007 in C code do.data[do.data > 0.007] = 0 do.eliminate_zeros() # make sure we have some comparable distances assert np.sum(do.data < 0.007) > 400 # do comparison over the region computed d = (do - dn)[:sn['vertno'][n_do - 1]][:, :sn['vertno'][n_do - 1]] assert_allclose(np.zeros_like(d.data), d.data, rtol=0, atol=1e-6)
def test_discrete_source_space(): """Test setting up (and reading/writing) discrete source spaces """ src = read_source_spaces(fname) v = src[0]['vertno'] # let's make a discrete version with the C code, and with ours temp_name = op.join(tempdir, 'temp-src.fif') try: # save temp_pos = op.join(tempdir, 'temp-pos.txt') np.savetxt(temp_pos, np.c_[src[0]['rr'][v], src[0]['nn'][v]]) # let's try the spherical one (no bem or surf supplied) run_subprocess(['mne_volume_source_space', '--meters', '--pos', temp_pos, '--src', temp_name]) src_c = read_source_spaces(temp_name) src_new = setup_volume_source_space('sample', None, pos=dict(rr=src[0]['rr'][v], nn=src[0]['nn'][v]), subjects_dir=subjects_dir) _compare_source_spaces(src_c, src_new, mode='approx') assert_allclose(src[0]['rr'][v], src_new[0]['rr'], rtol=1e-3, atol=1e-6) assert_allclose(src[0]['nn'][v], src_new[0]['nn'], rtol=1e-3, atol=1e-6) # now do writing write_source_spaces(temp_name, src_c) src_c2 = read_source_spaces(temp_name) _compare_source_spaces(src_c, src_c2) finally: if op.isfile(temp_name): os.remove(temp_name)
def __init_with_mne_sample_data(self): """ Initializes MEG, BEM, Source space and tranforms with MNE sample data """ self.data_path = os.path.abspath(join(self.subjects_dir, os.pardir)) self.subject_name = 'sample' self.raw_path = join(self.data_path, 'MEG', 'sample', 'sample_audvis_raw.fif') self.info = mne.io.read_info(self.raw_path) self.bem_path = join(self.data_path, 'subjects', 'sample', 'bem', 'sample-5120-5120-5120-bem-sol.fif') src_file = 'sample-' + self.spacing[0:3] + '-' + self.spacing[ -1] + '-src.fif' src_path = join(self.data_path, 'subjects', 'sample', 'bem', src_file) if not os.path.isfile(src_path): print( "Source space file not found, creating new source space file..." ) src = mne.setup_source_space(str('sample'), spacing=self.spacing) # write source spaces mne.write_source_spaces(src_path, src) self.src_path = src_path # self.trans_path = None self.trans_path = join(self.data_path, 'MEG', 'sample', 'sample_audvis_raw-trans.fif') self.cov_path = join(self.data_path, 'MEG', 'sample', 'sample_audvis-cov.fif') self.raw_empty_room_path = join(self.data_path, 'MEG', 'sample', 'ernoise_raw.fif')
def run_strural(subject, bem_ico=4, spacing='ico5', n_jobs=4, subjects_dir='/cluster/transcend/MRI/WMA/recons'): mne.bem.make_watershed_bem(subject, subjects_dir=subjects_dir, overwrite=True) src_fname = op.join(subjects_dir, subject, '%s-pyimpress-src.fif' % spacing) if not os.path.isfile(src_fname): src = mne.setup_source_space(subject, spacing=spacing, subjects_dir=subjects_dir, overwrite=True, n_jobs=n_jobs, add_dist=True) mne.write_source_spaces(src_fname, src) else: src = mne.read_source_spaces(src_fname) bem_fname = op.join(subjects_dir, subject, '%s-pyimpress-bem.fif' % bem_ico) if not os.path.isfile(bem_fname): bem_model = mne.make_bem_model(subject, ico=bem_ico, subjects_dir=subjects_dir, conductivity=(0.3, )) bem = mne.make_bem_solution(bem_model) mne.write_bem_solution(bem_fname, bem) else: bem = mne.read_bem_solution(bem_fname) return src, bem, src_fname, bem_fname
def test_volume_source_space(): """Test setting up volume source spaces.""" tempdir = _TempDir() src = read_source_spaces(fname_vol) temp_name = op.join(tempdir, 'temp-src.fif') surf = read_bem_surfaces(fname_bem, s_id=FIFF.FIFFV_BEM_SURF_ID_BRAIN) surf['rr'] *= 1e3 # convert to mm # The one in the testing dataset (uses bem as bounds) for bem, surf in zip((fname_bem, None), (None, surf)): src_new = setup_volume_source_space('sample', pos=7.0, bem=bem, surface=surf, mri='T1.mgz', subjects_dir=subjects_dir) write_source_spaces(temp_name, src_new, overwrite=True) src[0]['subject_his_id'] = 'sample' # XXX: to make comparison pass _compare_source_spaces(src, src_new, mode='approx') del src_new src_new = read_source_spaces(temp_name) _compare_source_spaces(src, src_new, mode='approx') assert_raises( IOError, setup_volume_source_space, 'sample', pos=7.0, bem=None, surface='foo', # bad surf mri=fname_mri, subjects_dir=subjects_dir) assert_equal(repr(src), repr(src_new)) assert_equal(src.kind, 'volume')
def process_subject_bem(subject, subjects_dir='/cluster/transcend/MRI/WMA/recons', spacing='ico4'): try: bem_fname = op.join(subjects_dir,subject,'bem', '%s-src.fif' % subject) src_fname = op.join(subjects_dir, subject, 'bem', '%s-src.fif' % spacing) #headsurf_log = op.join(subjects_dir, subject, 'bem', subject + '_headsurf.log') if not os.path.isfile(bem_fname): mne.bem.make_watershed_bem(subject=subject, subjects_dir=subjects_dir, overwrite=True, volume='T1', atlas=True, gcaatlas=False, preflood=None) conductivity = (0.3,) model = mne.make_bem_model(subject=subject, ico=4, conductivity=conductivity, subjects_dir=subjects_dir) bem = mne.make_bem_solution(model) mne.write_bem_solution(bem_fname, bem=bem) if not os.path.isfile(src_fname): src = mne.setup_source_space(subject, spacing=spacing, subjects_dir=subjects_dir, add_dist=False) mne.write_source_spaces(src_fname, src=src, overwrite=True) except Exception as ee: error = str(ee) print(subject, error) pass
def create_src_space(sbj_dir, sbj_id, spacing): """Create a source space.""" import os.path as op import mne bem_dir = op.join(sbj_dir, sbj_id, 'bem') # check if source space exists, if not it creates using mne-python fun # we have to create the cortical surface source space even when aseg is # True src_fname = op.join(bem_dir, '%s-%s-src.fif' % (sbj_id, spacing)) if not op.isfile(src_fname): src = mne.setup_source_space(sbj_id, subjects_dir=sbj_dir, spacing=spacing.replace('-', ''), add_dist=False, n_jobs=2) mne.write_source_spaces(src_fname, src, overwrite=True) print(('\n*** source space file %s written ***\n' % src_fname)) else: print(('\n*** source space file %s exists!!!\n' % src_fname)) src = mne.read_source_spaces(src_fname) return src
def test_write_source_space(): """Test writing and reading of source spaces """ src0 = read_source_spaces(fname, add_geom=False) src0_old = read_source_spaces(fname, add_geom=False) write_source_spaces(op.join(tempdir, 'tmp.fif'), src0) src1 = read_source_spaces(op.join(tempdir, 'tmp.fif'), add_geom=False) for orig in [src0, src0_old]: for s0, s1 in zip(src0, src1): for name in [ 'nuse', 'dist_limit', 'ntri', 'np', 'type', 'id', 'subject_his_id' ]: assert_true(s0[name] == s1[name]) for name in [ 'nn', 'rr', 'inuse', 'vertno', 'nuse_tri', 'coord_frame', 'use_tris', 'tris', 'nearest', 'nearest_dist' ]: assert_array_equal(s0[name], s1[name]) for name in ['dist']: if s0[name] is not None: assert_true(s1[name].shape == s0[name].shape) assert_true(len((s0['dist'] - s1['dist']).data) == 0) for name in ['pinfo']: if s0[name] is not None: assert_true(len(s0[name]) == len(s1[name])) for p1, p2 in zip(s0[name], s1[name]): assert_true(all(p1 == p2)) # The above "if s0[name] is not None" can be removed once the sample # dataset is updated to have a source space with distance info for name in ['working_dir', 'command_line']: assert_true(src0.info[name] == src1.info[name])
def test_write_source_space(): """Test writing and reading of source spaces """ src0 = read_source_spaces(fname, add_geom=False) src0_old = read_source_spaces(fname, add_geom=False) write_source_spaces(op.join(tempdir, 'tmp.fif'), src0) src1 = read_source_spaces(op.join(tempdir, 'tmp.fif'), add_geom=False) for orig in [src0, src0_old]: for s0, s1 in zip(src0, src1): for name in ['nuse', 'dist_limit', 'ntri', 'np', 'type', 'id', 'subject_his_id']: assert_true(s0[name] == s1[name]) for name in ['nn', 'rr', 'inuse', 'vertno', 'nuse_tri', 'coord_frame', 'use_tris', 'tris', 'nearest', 'nearest_dist']: assert_array_equal(s0[name], s1[name]) for name in ['dist']: if s0[name] is not None: assert_true(s1[name].shape == s0[name].shape) assert_true(len((s0['dist'] - s1['dist']).data) == 0) for name in ['pinfo']: if s0[name] is not None: assert_true(len(s0[name]) == len(s1[name])) for p1, p2 in zip(s0[name], s1[name]): assert_true(all(p1 == p2)) # The above "if s0[name] is not None" can be removed once the sample # dataset is updated to have a source space with distance info for name in ['working_dir', 'command_line']: assert_true(src0.info[name] == src1.info[name])
def create_source_space(subject, fsMRI_dir): print('Subject ' + subject + ': create_source_space ======================') meg_subject_dir = op.join(config.meg_dir, subject) # Create source space src = mne.setup_source_space(subject, spacing=config.spacing, subjects_dir=fsMRI_dir) mne.write_source_spaces(op.join(meg_subject_dir, subject + '-oct6-src.fif'), src, overwrite=True)
def test_volume_source_space(tmpdir): """Test setting up volume source spaces.""" src = read_source_spaces(fname_vol) temp_name = tmpdir.join('temp-src.fif') surf = read_bem_surfaces(fname_bem, s_id=FIFF.FIFFV_BEM_SURF_ID_BRAIN) surf['rr'] *= 1e3 # convert to mm bem_sol = read_bem_solution(fname_bem_3_sol) bem = read_bem_solution(fname_bem_sol) # The one in the testing dataset (uses bem as bounds) for this_bem, this_surf in zip( (bem, fname_bem, fname_bem_3, bem_sol, fname_bem_3_sol, None), (None, None, None, None, None, surf)): src_new = setup_volume_source_space('sample', pos=7.0, bem=this_bem, surface=this_surf, subjects_dir=subjects_dir) write_source_spaces(temp_name, src_new, overwrite=True) src[0]['subject_his_id'] = 'sample' # XXX: to make comparison pass _compare_source_spaces(src, src_new, mode='approx') del src_new src_new = read_source_spaces(temp_name) _compare_source_spaces(src, src_new, mode='approx') with pytest.raises(IOError, match='surface file.*not found'): setup_volume_source_space('sample', surface='foo', mri=fname_mri, subjects_dir=subjects_dir) bem['surfs'][-1]['coord_frame'] = FIFF.FIFFV_COORD_HEAD with pytest.raises(ValueError, match='BEM is not in MRI coord.* got head'): setup_volume_source_space('sample', bem=bem, mri=fname_mri, subjects_dir=subjects_dir) bem['surfs'] = bem['surfs'][:-1] # no inner skull surf with pytest.raises(ValueError, match='Could not get inner skul.*from BEM'): setup_volume_source_space('sample', bem=bem, mri=fname_mri, subjects_dir=subjects_dir) del bem assert repr(src) == repr(src_new) assert ' MB' in repr(src) assert src.kind == 'volume' # Spheres sphere = make_sphere_model(r0=(0., 0., 0.), head_radius=0.1, relative_radii=(0.9, 1.0), sigmas=(0.33, 1.0)) src = setup_volume_source_space(pos=10, sphere=(0., 0., 0., 0.09)) src_new = setup_volume_source_space(pos=10, sphere=sphere) _compare_source_spaces(src, src_new, mode='exact') with pytest.raises(ValueError, match='sphere, if str'): setup_volume_source_space(sphere='foo') # Need a radius sphere = make_sphere_model(head_radius=None) with pytest.raises(ValueError, match='be spherical with multiple layers'): setup_volume_source_space(sphere=sphere)
def createSrc(subj): camcan_root = os.environ['CAMCAN_ROOT'] ico4_fname = camcan_root + 'processed/cc700/mri/pipeline/release004/BIDSsep/megraw/' + subj + '/meg/' + subj + '-ico4-src.fif' try: src = mne.read_source_spaces(ico4_fname) except IOError: src = mne.setup_source_space(subj, spacing='ico4') mne.write_source_spaces(ico4_fname, src) return src
def test_setup_source_space(): """Test setting up ico, oct, and all source spaces.""" tempdir = _TempDir() fname_ico = op.join(data_path, 'subjects', 'fsaverage', 'bem', 'fsaverage-ico-5-src.fif') # first lets test some input params assert_raises(ValueError, setup_source_space, 'sample', spacing='oct', add_dist=False, subjects_dir=subjects_dir) assert_raises(ValueError, setup_source_space, 'sample', spacing='octo', add_dist=False, subjects_dir=subjects_dir) assert_raises(ValueError, setup_source_space, 'sample', spacing='oct6e', add_dist=False, subjects_dir=subjects_dir) assert_raises(ValueError, setup_source_space, 'sample', spacing='7emm', add_dist=False, subjects_dir=subjects_dir) assert_raises(ValueError, setup_source_space, 'sample', spacing='alls', add_dist=False, subjects_dir=subjects_dir) assert_raises(IOError, setup_source_space, 'sample', spacing='oct6', subjects_dir=subjects_dir, add_dist=False) # ico 5 (fsaverage) - write to temp file src = read_source_spaces(fname_ico) temp_name = op.join(tempdir, 'temp-src.fif') with warnings.catch_warnings(record=True): # sklearn equiv neighbors warnings.simplefilter('always') src_new = setup_source_space('fsaverage', temp_name, spacing='ico5', subjects_dir=subjects_dir, add_dist=False, overwrite=True) _compare_source_spaces(src, src_new, mode='approx') assert_equal(repr(src), repr(src_new)) assert_equal(repr(src).count('surface ('), 2) assert_array_equal(src[0]['vertno'], np.arange(10242)) assert_array_equal(src[1]['vertno'], np.arange(10242)) # oct-6 (sample) - auto filename + IO src = read_source_spaces(fname) temp_name = op.join(tempdir, 'temp-src.fif') with warnings.catch_warnings(record=True): # sklearn equiv neighbors warnings.simplefilter('always') src_new = setup_source_space('sample', None, spacing='oct6', subjects_dir=subjects_dir, overwrite=True, add_dist=False) write_source_spaces(temp_name, src_new, overwrite=True) _compare_source_spaces(src, src_new, mode='approx', nearest=False) src_new = read_source_spaces(temp_name) _compare_source_spaces(src, src_new, mode='approx', nearest=False) # all source points - no file writing src_new = setup_source_space('sample', None, spacing='all', subjects_dir=subjects_dir, add_dist=False) assert_true(src_new[0]['nuse'] == len(src_new[0]['rr'])) assert_true(src_new[1]['nuse'] == len(src_new[1]['rr'])) # dense source space to hit surf['inuse'] lines of _create_surf_spacing assert_raises(RuntimeError, setup_source_space, 'sample', None, spacing='ico6', subjects_dir=subjects_dir, add_dist=False)
def make_forward_solution(experiment, subject, spacing, process_slug=DEFAULT_PROC): struct = sub_to_struct[experiment][subject] if struct == 'NA': raise IOError( 'Freesurfer Reconstruction has not yet been done for this subject. See the Freesurfer Recommended Reconstruction page.') trans_fname = TRANS_FNAME.format(experiment=experiment, subject=subject, struct=struct) if not os.path.isfile(trans_fname): raise IOError( 'Coregistration has not yet been done for this subject. Use mne_analyze on big-brain and follow MNE handbook chapter 7.') trans = mne.read_trans(trans_fname) fwd_path = FWD_PATH.format(experiment=experiment, subject=subject) if not os.path.exists(fwd_path): try: os.mkdir(fwd_path) except: os.mkdir(FWD_PATH.format(experiment=experiment, subject='')) os.mkdir(fwd_path) fwd_fname = FWD_FNAME.format(fwd_path=fwd_path, subject=subject, experiment=experiment, process_slug=process_slug, struct=struct, spacing=spacing) raw = mne.io.Raw(PROC_FNAME.format(experiment=experiment, subject=subject, process_slug=process_slug)) bem_path = [fn for fn in os.listdir(BEM_PATH.format(struct=struct)) if fnmatch.fnmatch(fn, '*-bem-sol.fif')] if len(bem_path) == 0: raise IOError('BEM has not yet been done for this subject. See MNE_pipeline_2018.sh') bem_fname = pjoin(BEM_PATH.format(struct=struct), bem_path[0]) src_file = SRC_FNAME.format(struct=struct, spacing=spacing) mne.set_config('SUBJECTS_DIR', SUBJ_DIR) # Not sure how to make sure this runs effectively if os.path.isfile(src_file): src = mne.read_source_spaces(src_file) else: src = mne.setup_source_space(struct, spacing='oct6') mne.write_source_spaces(src_file, src) fwd = mne.make_forward_solution(raw.info, trans, src=src, bem=bem_fname) mne.write_forward_solution(fwd_fname, fwd) return fwd
def _get_bem_src_trans(p, info, subj, struc): subjects_dir = get_subjects_dir(p.subjects_dir, raise_error=True) assert isinstance(subjects_dir, str) if struc is None: # spherical case bem, src, trans = _spherical_conductor(info, subj, p.src_pos) bem_type = 'spherical-model' else: from mne.transforms import _ensure_trans trans = op.join(p.work_dir, subj, p.trans_dir, subj + '-trans.fif') if not op.isfile(trans): old = trans trans = op.join(p.work_dir, subj, p.trans_dir, subj + '-trans_head2mri.txt') if not op.isfile(trans): raise IOError('Unable to find head<->MRI trans files in:\n' '%s\n%s' % (old, trans)) trans = read_trans(trans) trans = _ensure_trans(trans, 'mri', 'head') this_src = _handle_dict(p.src, subj) assert isinstance(this_src, str) if this_src.startswith('oct'): kind = 'oct' elif this_src.startswith('vol'): kind = 'vol' else: raise RuntimeError('Unknown source space type %s, must be ' 'oct or vol' % (this_src, )) num = int(this_src.split(kind)[-1].split('-')[-1]) bem = op.join(subjects_dir, struc, 'bem', '%s-%s-bem-sol.fif' % (struc, p.bem_type)) for mid in ('', '-'): src_space_file = op.join( subjects_dir, struc, 'bem', '%s-%s%s%s-src.fif' % (struc, kind, mid, num)) if op.isfile(src_space_file): break else: # if neither exists, use last filename print(' Creating %s%s source space for %s...' % (kind, num, subj)) if kind == 'oct': src = setup_source_space(struc, spacing='%s%s' % (kind, num), subjects_dir=p.subjects_dir, n_jobs=p.n_jobs) else: assert kind == 'vol' src = setup_volume_source_space(struc, pos=num, bem=bem, subjects_dir=p.subjects_dir) write_source_spaces(src_space_file, src) src = read_source_spaces(src_space_file) bem = read_bem_solution(bem, verbose=False) bem_type = ('%s-layer BEM' % len(bem['surfs'])) return bem, src, trans, bem_type
def test_setup_source_space(tmpdir): """Test setting up ico, oct, and all source spaces.""" fname_ico = op.join(data_path, 'subjects', 'fsaverage', 'bem', 'fsaverage-ico-5-src.fif') # first lets test some input params for spacing in ('oct', 'oct6e'): with pytest.raises(ValueError, match='subdivision must be an integer'): setup_source_space('sample', spacing=spacing, add_dist=False, subjects_dir=subjects_dir) for spacing in ('oct0', 'oct-4'): with pytest.raises(ValueError, match='oct subdivision must be >= 1'): setup_source_space('sample', spacing=spacing, add_dist=False, subjects_dir=subjects_dir) with pytest.raises(ValueError, match='ico subdivision must be >= 0'): setup_source_space('sample', spacing='ico-4', add_dist=False, subjects_dir=subjects_dir) with pytest.raises(ValueError, match='must be a string with values'): setup_source_space('sample', spacing='7emm', add_dist=False, subjects_dir=subjects_dir) with pytest.raises(ValueError, match='must be a string with values'): setup_source_space('sample', spacing='alls', add_dist=False, subjects_dir=subjects_dir) # ico 5 (fsaverage) - write to temp file src = read_source_spaces(fname_ico) with pytest.warns(None): # sklearn equiv neighbors src_new = setup_source_space('fsaverage', spacing='ico5', subjects_dir=subjects_dir, add_dist=False) _compare_source_spaces(src, src_new, mode='approx') assert_equal(repr(src), repr(src_new)) assert_equal(repr(src).count('surface ('), 2) assert_array_equal(src[0]['vertno'], np.arange(10242)) assert_array_equal(src[1]['vertno'], np.arange(10242)) # oct-6 (sample) - auto filename + IO src = read_source_spaces(fname) temp_name = tmpdir.join('temp-src.fif') with pytest.warns(None): # sklearn equiv neighbors src_new = setup_source_space('sample', spacing='oct6', subjects_dir=subjects_dir, add_dist=False) write_source_spaces(temp_name, src_new, overwrite=True) assert_equal(src_new[0]['nuse'], 4098) _compare_source_spaces(src, src_new, mode='approx', nearest=False) src_new = read_source_spaces(temp_name) _compare_source_spaces(src, src_new, mode='approx', nearest=False) # all source points - no file writing src_new = setup_source_space('sample', spacing='all', subjects_dir=subjects_dir, add_dist=False) assert src_new[0]['nuse'] == len(src_new[0]['rr']) assert src_new[1]['nuse'] == len(src_new[1]['rr']) # dense source space to hit surf['inuse'] lines of _create_surf_spacing pytest.raises(RuntimeError, setup_source_space, 'sample', spacing='ico6', subjects_dir=subjects_dir, add_dist=False)
def test_setup_source_space(): """Test setting up ico, oct, and all source spaces.""" tempdir = _TempDir() fname_ico = op.join(data_path, 'subjects', 'fsaverage', 'bem', 'fsaverage-ico-5-src.fif') # first lets test some input params assert_raises(ValueError, setup_source_space, 'sample', spacing='oct', add_dist=False, subjects_dir=subjects_dir) assert_raises(ValueError, setup_source_space, 'sample', spacing='octo', add_dist=False, subjects_dir=subjects_dir) assert_raises(ValueError, setup_source_space, 'sample', spacing='oct6e', add_dist=False, subjects_dir=subjects_dir) assert_raises(ValueError, setup_source_space, 'sample', spacing='7emm', add_dist=False, subjects_dir=subjects_dir) assert_raises(ValueError, setup_source_space, 'sample', spacing='alls', add_dist=False, subjects_dir=subjects_dir) # ico 5 (fsaverage) - write to temp file src = read_source_spaces(fname_ico) with warnings.catch_warnings(record=True): # sklearn equiv neighbors warnings.simplefilter('always') src_new = setup_source_space('fsaverage', spacing='ico5', subjects_dir=subjects_dir, add_dist=False) _compare_source_spaces(src, src_new, mode='approx') assert_equal(repr(src), repr(src_new)) assert_equal(repr(src).count('surface ('), 2) assert_array_equal(src[0]['vertno'], np.arange(10242)) assert_array_equal(src[1]['vertno'], np.arange(10242)) # oct-6 (sample) - auto filename + IO src = read_source_spaces(fname) temp_name = op.join(tempdir, 'temp-src.fif') with warnings.catch_warnings(record=True): # sklearn equiv neighbors warnings.simplefilter('always') src_new = setup_source_space('sample', spacing='oct6', subjects_dir=subjects_dir, add_dist=False) write_source_spaces(temp_name, src_new, overwrite=True) assert_equal(src_new[0]['nuse'], 4098) _compare_source_spaces(src, src_new, mode='approx', nearest=False) src_new = read_source_spaces(temp_name) _compare_source_spaces(src, src_new, mode='approx', nearest=False) # all source points - no file writing src_new = setup_source_space('sample', spacing='all', subjects_dir=subjects_dir, add_dist=False) assert_true(src_new[0]['nuse'] == len(src_new[0]['rr'])) assert_true(src_new[1]['nuse'] == len(src_new[1]['rr'])) # dense source space to hit surf['inuse'] lines of _create_surf_spacing assert_raises(RuntimeError, setup_source_space, 'sample', spacing='ico6', subjects_dir=subjects_dir, add_dist=False)
def test_discrete_source_space(): """Test setting up (and reading/writing) discrete source spaces """ tempdir = _TempDir() src = read_source_spaces(fname) v = src[0]['vertno'] # let's make a discrete version with the C code, and with ours temp_name = op.join(tempdir, 'temp-src.fif') try: # save temp_pos = op.join(tempdir, 'temp-pos.txt') np.savetxt(temp_pos, np.c_[src[0]['rr'][v], src[0]['nn'][v]]) # let's try the spherical one (no bem or surf supplied) run_subprocess([ 'mne_volume_source_space', '--meters', '--pos', temp_pos, '--src', temp_name ]) src_c = read_source_spaces(temp_name) pos_dict = dict(rr=src[0]['rr'][v], nn=src[0]['nn'][v]) src_new = setup_volume_source_space('sample', None, pos=pos_dict, subjects_dir=subjects_dir) _compare_source_spaces(src_c, src_new, mode='approx') assert_allclose(src[0]['rr'][v], src_new[0]['rr'], rtol=1e-3, atol=1e-6) assert_allclose(src[0]['nn'][v], src_new[0]['nn'], rtol=1e-3, atol=1e-6) # now do writing write_source_spaces(temp_name, src_c) src_c2 = read_source_spaces(temp_name) _compare_source_spaces(src_c, src_c2) # now do MRI assert_raises(ValueError, setup_volume_source_space, 'sample', pos=pos_dict, mri=fname_mri) assert_equal(repr(src_new), repr(src_c)) assert_equal(src_new.kind, 'discrete') finally: if op.isfile(temp_name): os.remove(temp_name)
def test_write_source_space(tmpdir): """Test reading and writing of source spaces.""" src0 = read_source_spaces(fname, patch_stats=False) temp_fname = tmpdir.join('tmp-src.fif') write_source_spaces(temp_fname, src0) src1 = read_source_spaces(temp_fname, patch_stats=False) _compare_source_spaces(src0, src1) # test warnings on bad filenames src_badname = tmpdir.join('test-bad-name.fif.gz') with pytest.warns(RuntimeWarning, match='-src.fif'): write_source_spaces(src_badname, src0) with pytest.warns(RuntimeWarning, match='-src.fif'): read_source_spaces(src_badname)
def _create_mixed_source_space(subjects_dir, sbj_id, spacing, labels, src, save_mixed_src_space): """Create a miwed source space.""" bem_dir = op.join(subjects_dir, sbj_id, 'bem') src_aseg_fname = op.join(bem_dir, '%s-%s-aseg-src.fif' % (sbj_id, spacing)) if not op.isfile(src_aseg_fname): aseg_fname = op.join(subjects_dir, sbj_id, 'mri/aseg.mgz') if spacing == 'oct-6': pos = 5.0 elif spacing == 'oct-5': pos = 7.0 elif spacing == 'ico-5': pos = 3.0 model_fname = op.join(bem_dir, '%s-5120-bem.fif' % sbj_id) for l in labels: print(l) vol_label = mne.setup_volume_source_space( sbj_id, mri=aseg_fname, pos=pos, bem=model_fname, volume_label=l, subjects_dir=subjects_dir) # noqa src += vol_label if save_mixed_src_space: mne.write_source_spaces(src_aseg_fname, src, overwrite=True) print("\n*** source space file {} written " "***\n".format(src_aseg_fname)) # Export source positions to nift file nii_fname = op.join(bem_dir, '%s-%s-aseg-src.nii' % (sbj_id, spacing)) # Combine the source spaces src.export_volume(nii_fname, mri_resolution=True) else: print("\n*** source space file {} " "exists!!!\n".format(src_aseg_fname)) src = mne.read_source_spaces(src_aseg_fname) print(('src contains {} src spaces'.format(len(src)))) for s in src[2:]: print(('sub structure {} \n'.format(s['seg_name']))) return src
def test_source_space_from_label(tmpdir, pass_ids): """Test generating a source space from volume label.""" aseg_short = 'aseg.mgz' atlas_ids, _ = read_freesurfer_lut() volume_label = 'Left-Cerebellum-Cortex' # Test pos as dict pos = dict() with pytest.raises(ValueError, match='mri must be None if pos is a dict'): setup_volume_source_space('sample', pos=pos, volume_label=volume_label, mri=aseg_short, subjects_dir=subjects_dir) # Test T1.mgz provided with pytest.raises(RuntimeError, match=r'Must use a \*aseg.mgz file'): setup_volume_source_space('sample', mri='T1.mgz', volume_label=volume_label, subjects_dir=subjects_dir) # Test invalid volume label mri = aseg_short with pytest.raises(ValueError, match="'Left-Cerebral' not found.*Did you"): setup_volume_source_space('sample', volume_label='Left-Cerebral', mri=mri, subjects_dir=subjects_dir) # These should be equivalent if pass_ids: use_volume_label = {volume_label: atlas_ids[volume_label]} else: use_volume_label = volume_label # ensure it works even when not provided (detect that it should be aseg) src = setup_volume_source_space('sample', volume_label=use_volume_label, add_interpolator=False, subjects_dir=subjects_dir) assert_equal(volume_label, src[0]['seg_name']) assert src[0]['nuse'] == 404 # for our given pos and label # test reading and writing out_name = tmpdir.join('temp-src.fif') write_source_spaces(out_name, src) src_from_file = read_source_spaces(out_name) _compare_source_spaces(src, src_from_file, mode='approx')
def test_write_source_space(): """Test reading and writing of source spaces.""" tempdir = _TempDir() src0 = read_source_spaces(fname, patch_stats=False) write_source_spaces(op.join(tempdir, 'tmp-src.fif'), src0) src1 = read_source_spaces(op.join(tempdir, 'tmp-src.fif'), patch_stats=False) _compare_source_spaces(src0, src1) # test warnings on bad filenames src_badname = op.join(tempdir, 'test-bad-name.fif.gz') with pytest.warns(RuntimeWarning, match='-src.fif'): write_source_spaces(src_badname, src0) with pytest.warns(RuntimeWarning, match='-src.fif'): read_source_spaces(src_badname)
def process_subject_bem(subject, spacing='ico5'): mne.bem.make_watershed_bem(subject=subject, subjects_dir=subjects_dir, overwrite=True, volume='T1', atlas=True, gcaatlas=False, preflood=None) conductivity = (0.3,) model = mne.make_bem_model(subject=subject, ico=4, conductivity=conductivity, subjects_dir=subjects_dir) bem = mne.make_bem_solution(model) src = mne.setup_source_space(subject, spacing=spacing, subjects_dir=subjects_dir, add_dist=False) bem_fname = op.join(subjects_dir,subject,'bem', '%s-src.fif' % subject) src_fname = op.join(subjects_dir, subject, 'bem', '%s-src.fif' % spacing) mne.write_bem_solution(bem_fname, bem=bem) mne.write_source_spaces(src_fname, src=src)
def test_write_source_space(): """Test reading and writing of source spaces.""" tempdir = _TempDir() src0 = read_source_spaces(fname, patch_stats=False) write_source_spaces(op.join(tempdir, 'tmp-src.fif'), src0) src1 = read_source_spaces(op.join(tempdir, 'tmp-src.fif'), patch_stats=False) _compare_source_spaces(src0, src1) # test warnings on bad filenames with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') src_badname = op.join(tempdir, 'test-bad-name.fif.gz') write_source_spaces(src_badname, src0) read_source_spaces(src_badname) assert_naming(w, 'test_source_space.py', 2)
def test_write_source_space(): """Test writing and reading of source spaces """ tempdir = _TempDir() src0 = read_source_spaces(fname, add_geom=False) write_source_spaces(op.join(tempdir, 'tmp-src.fif'), src0) src1 = read_source_spaces(op.join(tempdir, 'tmp-src.fif'), add_geom=False) _compare_source_spaces(src0, src1) # test warnings on bad filenames with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') src_badname = op.join(tempdir, 'test-bad-name.fif.gz') write_source_spaces(src_badname, src0) read_source_spaces(src_badname) assert_equal(len(w), 2)
def test_write_source_space(): """Test writing and reading of source spaces """ src0 = read_source_spaces(fname, add_geom=False) write_source_spaces(op.join(tempdir, 'tmp-src.fif'), src0) src1 = read_source_spaces(op.join(tempdir, 'tmp-src.fif'), add_geom=False) _compare_source_spaces(src0, src1) # test warnings on bad filenames with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') src_badname = op.join(tempdir, 'test-bad-name.fif.gz') write_source_spaces(src_badname, src0) read_source_spaces(src_badname) print([ww.message for ww in w]) assert_equal(len(w), 2)
def _make_vol_source_space(self): srcfilename = opj(self.fsrc, self.subject + "-vol-src.fif") if not os.path.isfile(srcfilename): try: src_vol = mne.setup_volume_source_space( self.subject, pos=3.0, subjects_dir=self.subjects_dir, verbose=True) mne.write_source_spaces(srcfilename, src_vol, overwrite=True, verbose=True) except Exception as e: print( f"Failed to setup volume source space for {self.subject} --> {e}" )
def test_add_source_space_distances(): """Test adding distances to source space.""" tempdir = _TempDir() src = read_source_spaces(fname) src_new = read_source_spaces(fname) del src_new[0]['dist'] del src_new[1]['dist'] n_do = 19 # limit this for speed src_new[0]['vertno'] = src_new[0]['vertno'][:n_do].copy() src_new[1]['vertno'] = src_new[1]['vertno'][:n_do].copy() out_name = op.join(tempdir, 'temp-src.fif') n_jobs = 2 assert n_do % n_jobs != 0 add_source_space_distances(src_new, n_jobs=n_jobs) write_source_spaces(out_name, src_new) src_new = read_source_spaces(out_name) # iterate over both hemispheres for so, sn in zip(src, src_new): v = so['vertno'][:n_do] assert_array_equal(so['dist_limit'], np.array([-0.007], np.float32)) assert_array_equal(sn['dist_limit'], np.array([np.inf], np.float32)) do = so['dist'] dn = sn['dist'] # clean out distances > 0.007 in C code (some residual), and Python ds = list() for d in [do, dn]: d.data[d.data > 0.007] = 0 d = d[v][:, v] d.eliminate_zeros() ds.append(d) # make sure we actually calculated some comparable distances assert np.sum(ds[0].data < 0.007) > 10 # do comparison d = ds[0] - ds[1] assert_allclose(np.zeros_like(d.data), d.data, rtol=0, atol=1e-9)
def test_discrete_source_space(): """Test setting up (and reading/writing) discrete source spaces.""" tempdir = _TempDir() src = read_source_spaces(fname) v = src[0]['vertno'] # let's make a discrete version with the C code, and with ours temp_name = op.join(tempdir, 'temp-src.fif') try: # save temp_pos = op.join(tempdir, 'temp-pos.txt') np.savetxt(temp_pos, np.c_[src[0]['rr'][v], src[0]['nn'][v]]) # let's try the spherical one (no bem or surf supplied) run_subprocess(['mne_volume_source_space', '--meters', '--pos', temp_pos, '--src', temp_name]) src_c = read_source_spaces(temp_name) pos_dict = dict(rr=src[0]['rr'][v], nn=src[0]['nn'][v]) src_new = setup_volume_source_space(pos=pos_dict) assert src_new.kind == 'discrete' _compare_source_spaces(src_c, src_new, mode='approx') assert_allclose(src[0]['rr'][v], src_new[0]['rr'], rtol=1e-3, atol=1e-6) assert_allclose(src[0]['nn'][v], src_new[0]['nn'], rtol=1e-3, atol=1e-6) # now do writing write_source_spaces(temp_name, src_c, overwrite=True) src_c2 = read_source_spaces(temp_name) finally: if op.isfile(temp_name): os.remove(temp_name) _compare_source_spaces(src_c, src_c2) # now do MRI pytest.raises(ValueError, setup_volume_source_space, 'sample', pos=pos_dict, mri=fname_mri) assert repr(src_new) == repr(src_c) assert src_new.kind == 'discrete' assert _get_src_type(src_new, None) == 'discrete'
def test_volume_source_space(): """Test setting up volume source spaces.""" tempdir = _TempDir() src = read_source_spaces(fname_vol) temp_name = op.join(tempdir, 'temp-src.fif') surf = read_bem_surfaces(fname_bem, s_id=FIFF.FIFFV_BEM_SURF_ID_BRAIN) surf['rr'] *= 1e3 # convert to mm # The one in the testing dataset (uses bem as bounds) for bem, surf in zip((fname_bem, None), (None, surf)): src_new = setup_volume_source_space( 'sample', pos=7.0, bem=bem, surface=surf, mri='T1.mgz', subjects_dir=subjects_dir) write_source_spaces(temp_name, src_new, overwrite=True) src[0]['subject_his_id'] = 'sample' # XXX: to make comparison pass _compare_source_spaces(src, src_new, mode='approx') del src_new src_new = read_source_spaces(temp_name) _compare_source_spaces(src, src_new, mode='approx') assert_raises(IOError, setup_volume_source_space, 'sample', pos=7.0, bem=None, surface='foo', # bad surf mri=fname_mri, subjects_dir=subjects_dir) assert_equal(repr(src), repr(src_new)) assert_equal(src.kind, 'volume')
# Setup a volume source space # set pos=7.0 for speed issue vol_src = setup_volume_source_space(subject, mri=fname_aseg, pos=7.0, bem=fname_model, volume_label=labels_vol, subjects_dir=subjects_dir) # Generate the mixed source space src += vol_src n = sum(src[i]['nuse'] for i in range(len(src))) print('the src space contains %d spaces and %d points' % (len(src), n)) # Write the mixed source space write_source_spaces(fname_mixed_src, src) # Export source positions to nift file nii_fname = op.join(bem_dir, '%s-mixed-src.nii' % subject) src.export_volume(nii_fname, mri_resolution=True) plotting.plot_img(nii_fname, cmap=plt.cm.spectral) plt.show() # Compute the fwd matrix fwd = make_forward_solution(fname_evoked, fname_trans, src, fname_bem, mindist=5.0, # ignore sources<=5mm from innerskull meg=True, eeg=False, n_jobs=1, overwrite=True)
maps = mne.make_field_map(evoked[0], trans_fname, subject='spm', subjects_dir=subjects_dir, n_jobs=1) evoked[0].plot_field(maps, time=0.170) ############################################################################### # Compute forward model # Make source space src_fname = data_path + '/subjects/spm/bem/spm-oct-6-src.fif' if not op.isfile(src_fname): src = mne.setup_source_space('spm', spacing='oct6', subjects_dir=subjects_dir) mne.write_source_spaces(src_fname, src) else: src = mne.read_source_spaces(src_fname) bem = data_path + '/subjects/spm/bem/spm-5120-5120-5120-bem-sol.fif' forward = mne.make_forward_solution(contrast.info, trans_fname, src, bem) forward = mne.convert_forward_solution(forward, surf_ori=True) ############################################################################### # Compute inverse solution snr = 3.0 lambda2 = 1.0 / snr ** 2 method = 'dSPM' inverse_operator = make_inverse_operator(contrast.info, forward, noise_cov,
from __future__ import print_function import mne import subprocess import sys import os from my_settings import * subject = sys.argv[1] # make source space src = mne.setup_source_space(subject, spacing='oct6', subjects_dir=subjects_dir, add_dist=False, overwrite=True) # save source space mne.write_source_spaces(mne_folder + "%s-oct-6-src.fif" % subject, src)
src_fs, subjects_dir=subjects_dir) src_fs[0]['subject_his_id'] = 'fsaverage' # name mismatch pytest.raises(ValueError, stc_morph.to_original_src, src_fs, subject_orig='foo', subjects_dir=subjects_dir) src_fs[0]['subject_his_id'] = 'sample' src = read_source_spaces(fname) # wrong source space pytest.raises(RuntimeError, stc_morph.to_original_src, src, subjects_dir=subjects_dir) run_tests_if_main() # The following code was used to generate small-src.fif.gz. # Unfortunately the C code bombs when trying to add source space distances, # possibly due to incomplete "faking" of a smaller surface on our part here. """ # -*- coding: utf-8 -*- import os import numpy as np import mne data_path = mne.datasets.sample.data_path() src = mne.setup_source_space('sample', fname=None, spacing='oct5') hemis = ['lh', 'rh'] fnames = [data_path + '/subjects/sample/surf/%s.decimated' % h for h in hemis] vs = list() for s, fname in zip(src, fnames): coords = s['rr'][s['vertno']] vs.append(s['vertno'])
os.chdir(raw_dir) subs = ['NLR_102_RS','NLR_103_AC','NLR_105_BB','NLR_110_HH','NLR_127_AM', 'NLR_130_RW','NLR_132_WP','NLR_133_ML','NLR_145_AC','NLR_150_MG','NLR_151_RD', 'NLR_152_TC','NLR_160_EK','NLR_161_AK','NLR_162_EF','NLR_163_LF','NLR_164_SF', 'NLR_170_GM','NLR_172_TH','NLR_174_HS','NLR_179_GM','NLR_180_ZD','NLR_187_NB', 'NLR_201_GS','NLR_202_DD','NLR_203_AM','NLR_204_AM','NLR_205_AC','NLR_206_LM', 'NLR_207_AH','NLR_210_SB','NLR_211_LB' ] subs = ['NLR_GB310','NLR_KB218','NLR_JB423','NLR_GB267','NLR_JB420','NLR_HB275','NLR_197_BK','NLR_GB355','NLR_GB387'] subs = ['NLR_HB205','NLR_IB319','NLR_JB227','NLR_JB486','NLR_KB396'] subs = ['NLR_JB227','NLR_JB486','NLR_KB396'] for n, s in enumerate(subs): subject = s # Create source space os.chdir(os.path.join(fs_dir,subject,'bem')) """ NLR_205: Head is too small to create ico5 """ if s == 'NLR_205_AC' or s == 'NLR_JB227': spacing='oct6' # ico5 = 10242, oct6 = 4098 ...8196 = 4098 * 2 fn2 = subject + '-' + 'oct-6' + '-src.fif' else: spacing='ico5' # 10242 * 2 fn2 = subject + '-' + 'ico-5' + '-src.fif' src = mne.setup_source_space(subject=subject, spacing=spacing, # source spacing = 5 mm subjects_dir=fs_dir, add_dist=False, n_jobs=18, overwrite=True) src = mne.add_source_space_distances(src, dist_limit=np.inf, n_jobs=18, verbose=None) mne.write_source_spaces(fn2, src, overwrite=True)