def test_simulate_stc_labels_overlap(_get_fwd_labels): """Test generation of source estimate, overlapping labels.""" fwd, labels = _get_fwd_labels mylabels = [] for i, label in enumerate(labels): new_label = Label(vertices=label.vertices, pos=label.pos, values=2 * i * np.ones(len(label.values)), hemi=label.hemi, comment=label.comment) mylabels.append(new_label) # Adding the last label twice mylabels.append(new_label) n_times = 10 tmin = 0 tstep = 1e-3 stc_data = np.ones((len(mylabels), n_times)) # Test false with pytest.raises(RuntimeError, match='must be non-overlapping'): simulate_stc(fwd['src'], mylabels, stc_data, tmin, tstep, allow_overlap=False) # test True stc = simulate_stc(fwd['src'], mylabels, stc_data, tmin, tstep, allow_overlap=True) assert_equal(stc.subject, 'sample') assert (stc.data.shape[1] == n_times) # Some of the elements should be equal to 2 since we have duplicate labels assert (2 in stc.data)
def test_simulate_stc(_get_fwd_labels): """Test generation of source estimate.""" fwd, labels = _get_fwd_labels mylabels = [] for i, label in enumerate(labels): new_label = Label(vertices=label.vertices, pos=label.pos, values=2 * i * np.ones(len(label.values)), hemi=label.hemi, comment=label.comment) mylabels.append(new_label) n_times = 10 tmin = 0 tstep = 1e-3 stc_data = np.ones((len(labels), n_times)) stc = simulate_stc(fwd['src'], mylabels, stc_data, tmin, tstep) assert_equal(stc.subject, 'sample') for label in labels: idx = _get_idx_label_stc(label, stc) assert (np.all(stc.data[idx] == 1.0)) assert (stc.data[idx].shape[1] == n_times) # test with function def fun(x): return x**2 stc = simulate_stc(fwd['src'], mylabels, stc_data, tmin, tstep, fun) # the first label has value 0, the second value 2, the third value 6 for i, label in enumerate(labels): idx = _get_idx_label_stc(label, stc) res = ((2. * i)**2.) * np.ones((len(idx), n_times)) assert_array_almost_equal(stc.data[idx], res) # degenerate conditions label_subset = mylabels[:2] data_subset = stc_data[:2] stc = simulate_stc(fwd['src'], label_subset, data_subset, tmin, tstep, fun) pytest.raises(ValueError, simulate_stc, fwd['src'], label_subset, data_subset[:-1], tmin, tstep, fun) pytest.raises(RuntimeError, simulate_stc, fwd['src'], label_subset * 2, np.concatenate([data_subset] * 2, axis=0), tmin, tstep, fun) i = np.where(fwd['src'][0]['inuse'] == 0)[0][0] label_single_vert = Label(vertices=[i], pos=fwd['src'][0]['rr'][i:i + 1, :], hemi='lh') stc = simulate_stc(fwd['src'], [label_single_vert], stc_data[:1], tmin, tstep) assert_equal(len(stc.lh_vertno), 1)
def test_generate_stc_single_hemi(_get_fwd_labels): """Test generation of source estimate, single hemi.""" fwd, labels = _get_fwd_labels labels_single_hemi = labels[1:] # keep only labels in one hemisphere mylabels = [] for i, label in enumerate(labels_single_hemi): new_label = Label(vertices=label.vertices, pos=label.pos, values=2 * i * np.ones(len(label.values)), hemi=label.hemi, comment=label.comment) mylabels.append(new_label) n_times = 10 tmin = 0 tstep = 1e-3 stc_data = np.ones((len(labels_single_hemi), n_times)) stc = simulate_stc(fwd['src'], mylabels, stc_data, tmin, tstep) for label in labels_single_hemi: idx = _get_idx_label_stc(label, stc) assert (np.all(stc.data[idx] == 1.0)) assert (stc.data[idx].shape[1] == n_times) # test with function def fun(x): return x**2 stc = simulate_stc(fwd['src'], mylabels, stc_data, tmin, tstep, fun) # the first label has value 0, the second value 2, the third value 6 for i, label in enumerate(labels_single_hemi): if label.hemi == 'lh': hemi_idx = 0 else: hemi_idx = 1 idx = np.intersect1d(stc.vertices[hemi_idx], label.vertices) idx = np.searchsorted(stc.vertices[hemi_idx], idx) if hemi_idx == 1: idx += len(stc.vertices[0]) res = ((2. * i)**2.) * np.ones((len(idx), n_times)) assert_array_almost_equal(stc.data[idx], res)
# Convert the center of vertex index from surface vertex list to Label's # vertex list. cent_idx = np.where(label.vertices == com)[0][0] # Create a mask with 1 at center vertex and zeros elsewhere. labels[i].values.fill(0.) labels[i].values[cent_idx] = 1. ############################################################################### # Create source-space data with known signals # ------------------------------------------- # # Put known signals onto surface vertices using the array of signals and # the label masks (stored in labels[i].values). stc_gen = simulate_stc(fwd['src'], labels, signal, times[0], dt, value_fun=lambda x: x) ############################################################################### # Plot original signals # --------------------- # # Note that the original signals are highly concentrated (point) sources. # kwargs = dict(subjects_dir=subjects_dir, hemi='split', smoothing_steps=4, time_unit='s', initial_time=0.05, size=1200, views=['lat', 'med']) clim = dict(kind='value', pos_lims=[1e-9, 1e-8, 1e-7]) figs = [mlab.figure(1), mlab.figure(2), mlab.figure(3), mlab.figure(4)] brain_gen = stc_gen.plot(clim=clim, figure=figs, **kwargs) ###############################################################################
def simulate_eeg(label_names, signal_generator, epoch_duration=3.0, n_trials=10): # Getting the paths to filenames of dataset data_path = sample.data_path() raw_fname = data_path + '/MEG/sample/sample_audvis_raw.fif' trans_fname = data_path + '/MEG/sample/sample_audvis_raw-trans.fif' bem_fname = (data_path + '/subjects/sample/bem/sample-5120-5120-5120-bem-sol.fif') # Load real data as the template raw = mne.io.read_raw_fif(raw_fname) raw = raw.crop(0., n_trials * epoch_duration) # Loading parameters for the forward solution fwd_fname = data_path + '/MEG/sample/sample_audvis-meg-eeg-oct-6-fwd.fif' fwd = mne.read_forward_solution(fwd_fname, force_fixed=True, surf_ori=True) fwd = mne.pick_types_forward(fwd, meg=False, eeg=True, ref_meg=False, exclude=raw.info['bads']) # Get the labels and their centers labels = [ mne.read_label(data_path + '/MEG/sample/labels/%s.label' % ln) for ln in label_names ] subjects_dir = data_path + '/subjects' hemi_to_ind = {'lh': 0, 'rh': 1} for i, label in enumerate(labels): # The `center_of_mass` function needs labels to have values. labels[i].values.fill(1.) # Restrict the eligible vertices to be those on the surface under # consideration and within the label. surf_vertices = fwd['src'][hemi_to_ind[label.hemi]]['vertno'] restrict_verts = np.intersect1d(surf_vertices, label.vertices) com = labels[i].center_of_mass(subject='sample', subjects_dir=subjects_dir, restrict_vertices=restrict_verts, surf='white') # Convert the center of vertex index from surface vertex list # to Label's vertex list. cent_idx = np.where(label.vertices == com)[0][0] # Create a mask with 1 at center vertex and zeros elsewhere. labels[i].values.fill(0.) labels[i].values[cent_idx] = 1. n_labels = len(label_names) times = raw.times[:int(raw.info['sfreq'] * epoch_duration)] signal = signal_generator(n_labels, times) # Generate the sources in each label dt = times[1] - times[0] stc = simulate_stc(fwd['src'], labels, signal, times[0], dt, value_fun=lambda x: x) # Simulate raw data raw_sim = simulate_raw(raw, stc, trans_fname, fwd['src'], bem_fname, cov='simple', iir_filter=[2, -2, 0.4], ecg=False, blink=False, n_jobs=1, verbose=True) # Get just the EEG data and the stimulus channel raw_eeg = raw_sim.load_data().pick_types(meg=False, eeg=True, stim=True) return raw_eeg
sens_data_list_rois = [] for ri, roi_name in enumerate(rois): # Deal with labels that potentially had to be loaded from parc if roi_name == 'G_temp_sup-G_T_transv-rh.label': subj_d[di]['rois'].append(aud_labels[si]) else: label_fname = op.join(struct_dir, subj_d[di]['Struct'], 'label', roi_name) subj_d[di]['rois'].append(mne.read_label(label_fname, subject=subj_d[di]['Struct'])) # Construct stc with active vertices belonging to the correct label/ROI n_verts = len(subj_d[di]['rois'][-1].vertices) data_arr = np.array([(1. / n_verts)])[np.newaxis, :] temp_stc = simulate_stc(src=subj_d[di]['src'], labels=[subj_d[di]['rois'][ri]], stc_data=data_arr, tmin=0, tstep=1) # Create evoked object to plot on scalp map fake_evo = mne.simulation.simulate_evoked(fwd, temp_stc, subj_d[di]['info'], cov, snr=np.inf, verbose=False) normed_data = fake_evo.data / np.max(np.abs(fake_evo.data)) sens_data_list_rois.append(np.squeeze(normed_data)) subj_d[di]['evo'].append(mne.EvokedArray(normed_data, subj_d[di]['info'], 0, verbose=False)) sens_data_list.append(sens_data_list_rois) p_bar.update(si) # update progress bar
verts_used = fsaverage['lab'].get_vertices_used() # Generate souce estimate stc_activation = sim_amplitude * np.ones((1, trial_len_ms * n_trials)) / \ len(s_dict['lab'].vertices) # Generate a template raw object raw_template = mne.io.RawArray(np.zeros((len(s_dict['info']['chs']), stc_activation.shape[1])), info=s_dict['info']) # Get scalar for noise covariance to achieve desired SNR noiseless_act = np.ones((1, 3)) * sim_amplitude raw_template_noiseless = mne.io.RawArray(np.zeros((len(s_dict['info']['chs']), noiseless_act.shape[1])), info=s_dict['info']) stc_noiseless = simulate_stc(subj_d[di]['inv']['src'], [subj_d[di]['lab']], stc_data=noiseless_act, tmin=0, tstep=0.001) eeg_noiseless = simulate_raw(raw_template_noiseless, stc_noiseless, s_dict['inv']['mri_head_t'], src=s_dict['inv']['src'], bem=s_dict['bem_fname'], cov=None, blink=True, n_jobs=n_jobs, verbose=False) s_dict['noise_scale'] = get_noise_scale(eeg_noiseless, s_dict) print 'Noise covariance scalar calculated: %s' % s_dict['noise_scale'] # Simulate cortical activations. # Maintain: Noise # Switch: Noise + [unit current / label area] in RTPJ raw_sim = [] stc_est = [] stc_est_sph = []