mag=0.05, grad=0.05, eeg=0.1, proj=True) data_cov = mne.compute_covariance(epochs, tmin=0.04, tmax=0.15) # Run free orientation (vector) beamformer. Source orientation can be # restricted by setting pick_ori to 'max-power' (or 'normal' but only when # using a surface-based source space) stc = lcmv(evoked, forward, noise_cov, data_cov, reg=0.01, pick_ori=None) # Save result in stc files stc.save('lcmv-vol') stc.crop(0.0, 0.2) # Save result in a 4D nifti file img = mne.save_stc_as_volume('lcmv_inverse.nii.gz', stc, forward['src'], mri_resolution=False) # True for full MRI resolution # plot result (one slice) plt.close('all') data = img.get_data() coronal_slice = data[:, 10, :, 60] plt.figure() plt.imshow(np.ma.masked_less(coronal_slice, 1), cmap=plt.cm.Reds, interpolation='nearest') plt.colorbar() plt.contour(coronal_slice != 0, 1, colors=['black']) plt.xticks([]) plt.yticks([]) # plot source time courses with the maximum peak amplitudes plt.figure()
def compute_lcmv_example_data(data_path, fname=None): raw_fname = data_path + '/MEG/sample/sample_audvis_raw.fif' event_fname = data_path + '/MEG/sample/sample_audvis_raw-eve.fif' fname_fwd = data_path + '/MEG/sample/sample_audvis-meg-vol-7-fwd.fif' # Get epochs event_id, tmin, tmax = [1, 2], -0.2, 0.5 # Setup for reading the raw data raw = mne.io.read_raw_fif(raw_fname, preload=True) raw.info['bads'] = ['MEG 2443', 'EEG 053'] # 2 bad channels events = mne.read_events(event_fname) # Set up pick list: gradiometers and magnetometers, excluding bad channels picks = mne.pick_types(raw.info, meg=True, eeg=False, stim=True, eog=True, exclude='bads') # Pick the channels of interest raw.pick_channels([raw.ch_names[pick] for pick in picks]) # Re-normalize our empty-room projectors, so they are fine after # subselection raw.info.normalize_proj() # Read epochs proj = False # already applied epochs = mne.Epochs(raw, events, event_id, tmin, tmax, baseline=(None, 0), preload=True, proj=proj, reject=dict(grad=4000e-13, mag=4e-12, eog=150e-6)) evoked = epochs.average() # Read regularized noise covariance and compute regularized data covariance noise_cov = mne.compute_covariance(epochs, tmin=tmin, tmax=0, method='shrunk') data_cov = mne.compute_covariance(epochs, tmin=0.04, tmax=0.15, method='shrunk') # Read forward model forward = mne.read_forward_solution(fname_fwd) # Compute weights of free orientation (vector) beamformer with weight # normalization (neural activity index, NAI). Providing a noise covariance # matrix enables whitening of the data and forward solution. Source # orientation is optimized by setting pick_ori to 'max-power'. # weight_norm can also be set to 'unit-noise-gain'. Source orientation can # also be 'normal' (but only when using a surface-based source space) or # None, which computes a vector beamfomer. Note, however, that not all # combinations of orientation selection and weight normalization are # implemented yet. filters = make_lcmv(evoked.info, forward, data_cov, reg=0.05, noise_cov=noise_cov, pick_ori='max-power', weight_norm='nai') # Apply this spatial filter to the evoked data. stc = apply_lcmv(evoked, filters, max_ori_out='signed') # take absolute values for plotting stc.data[:, :] = np.abs(stc.data) # Save result in stc files if desired if fname is not None: stc.save('lcmv-vol') # select time window (tmin, tmax) in ms - consider changing for real data # scenario, since those values were chosen to optimize computation time stc.crop(0.087, 0.087) src = forward['src'] # Save result in a 4D nifti file img = mne.save_stc_as_volume(fname, stc, src, mri_resolution=True) return img, stc, src
# take absolute values for plotting stc2.data = np.abs(stc.data.copy()) #stc.data = np.abs(stc.data) ax[1, 0].plot(x_ax, stc2.data[np.argsort(np.max(stc2.data, axis=1))[-40:]].T) # -40: plots the last (highest?) 40 voxels\ ax[1, 0].set_ylabel('LCMV value') ax[1, 0].set_xlabel('Time (ms)') ax[1, 0].set_xlim(-200, 500) #(x_ax[0], x_ax[-1]) ax[1, 0].set_title('%s %s, reg=%.3f, ' ' 40 max voxels' % (megtype, 'flash', rv)) # plot brain activity at the max mimum time point in volume vox, timep = np.unravel_index(stc.data.argmax(), stc.data.shape) img_mne = mne.save_stc_as_volume(op.join(reg_folder, 'test.nii.gz'), stc2, fwd['src']) if trial is 'pulse': timep = abs(stc.times + .001).argmin() else: timep = abs(stc.times - 0.108).argmin() # plotting threshold based on activity: thresh = np.max(stc2.data[:, timep]) * 0.75 #which_times=find_subset(stc.times,.105,.110) #timep=which_times # voxel 128.0 128.0 48.0, mm 1.0 -81.0 1.0 coords = (1,81,1)# fwd['source_rr'][vox] # plot statistical map on volume plot_stat_map( index_img(img_mne, timep), t1_fname,
def set_up(cfg): '''Calculate NNs, generate replications ''' # extract relevant paths subjectsDir = cfg["file_io"]["dirs"]["subjectsDir"] simDir = cfg["file_io"]["dirs"]["simDir"] relDir = cfg["file_io"]["dirs"]["relDir"] os.environ["SUBJECTS_DIR"] = subjectsDir # extract settings for finding nearest neighbours nbrhd = cfg["reliability_mapping"]["nn"]["neighbourhood"] rad = cfg["reliability_mapping"]["nn"]["radius"] # extract settings for data division into replications num_rep = cfg["reliability_mapping"]["data_division"]["num_replications"] chron = cfg["reliability_mapping"]["data_division"]["chronological"] # extract settings for data processing & beamformer baseStart = cfg["data_processing"]["baseline"]["baseStart"] baseEnd = cfg["data_processing"]["baseline"]["baseEnd"] bfBaselineMin = cfg["data_processing"]["LCMV"]["bfBaselineMin"] bfBaselineMax = cfg["data_processing"]["LCMV"]["bfBaselineMax"] bfActiveMin = cfg["data_processing"]["LCMV"]["bfActiveMin"] bfActiveMax = cfg["data_processing"]["LCMV"]["bfActiveMax"] regularization = cfg["data_processing"]["LCMV"]["regularization"] #spacing = cfg["data_processing"]["LCMV"]["spacing"] for subject_id in cfg["studySettings"]["subjects"]: # subject-specific data: subjectDir = os.path.join(subjectsDir, subject_id) mriFile = os.path.join(subjectDir, 'mri', 'T1-neuromag', 'sets', cfg["file_io"]["file_ext"]["mri_fif"]) bemFile = os.path.join(subjectDir, 'bem', "".join([subject_id, cfg["file_io"]["file_ext"]["bem_fif"]])) srcFile = os.path.join(subjectDir, 'bem', "".join([subject_id, cfg["file_io"]["file_ext"]["src_fif"]])) # nearest neighbours csv file to write to nnFile = os.path.join(subjectDir, 'bem', "".join([subject_id, cfg["file_io"]["file_ext"]["nn_file"]])) # find nearest neighbours for each point in src space and write to file sf.get_nn_src(srcFile, nnFile, nbrhd, rad) for sim_mode in cfg["studySettings"]["sim_modes"]: # split epochs file into a number of epochs files (ie. replications) & save an ERB map for each epochFile = os.path.join(simDir, 'sim_data', subject_id, sim_mode, cfg["file_io"]["file_ext"]["sim_epoch_fif"]) repDir = os.path.join(relDir, subject_id, sim_mode) if not os.path.exists(repDir): logger.debug("Path does not exist. Making {}".format(repDir)) os.makedirs(repDir) # read in & divide epochs logger.info("Reading epoch data ...") epochs = mne.read_epochs(epochFile) if epochs.info['sfreq'] == 1000.: pass else: logger.debug('Resampling epochs to 1000 Hz') epochs.resample(1000., npad=0) idxs = np.arange(len(epochs)) if chron == False: random.shuffle(idxs) splits = np.array_split(idxs, num_rep) # note: number of epochs in each replication may differ by 1 # get forward solution fwdFile = os.path.join(simDir, 'python_data', subject_id, "".join(['SEF_good', cfg["file_io"]["file_ext"]["forward_fif"]])) if os.path.exists(fwdFile): pass else: logger.debug("Forward solution does not exist. Making forward solution.") src = mne.read_source_spaces(srcFile) forward = mne.make_forward_solution(epochs.info, trans=mriFile, src=src, bem=bemFile, meg=True, eeg=False) mne.write_forward_solution(fwdFile, forward, overwrite=True) forward = mne.read_forward_solution(fwdFile) split_num = 1 # create ERB map for each replication for split in splits: evoked = epochs[split].average() evoked.apply_baseline((baseStart, baseEnd)) # calculate covariance noise_cov = mne.compute_covariance(epochs[split], tmin=bfBaselineMin, tmax=bfBaselineMax, n_jobs = 4) data_cov = mne.compute_covariance(epochs[split], tmin=bfActiveMin, tmax=bfActiveMax, n_jobs = 4) # run LCMV beamformer filters = mne.beamformer.make_lcmv(epochs.info, forward, data_cov, reg=regularization, noise_cov=noise_cov, pick_ori='max-power') stc = mne.beamformer.apply_lcmv(evoked, filters) # crop beamformer result to times of interest stc.crop(bfActiveMin, bfActiveMax) # take absolute value of beamformer (to eliminate anti-phase issue) np.abs(stc.data, out=stc.data) # save ERB maps niiFile = os.path.join(repDir, "".join(['replication_', str(split_num), '_', cfg["file_io"]["file_ext"]["nifti_file"]])) mne.save_stc_as_volume(niiFile, stc, forward['src'], dest='surf', mri_resolution=False) split_num = split_num + 1 # also create an ERB map for the entire dataset evoked = epochs.average() evoked.apply_baseline((baseStart, baseEnd)) # calculate covariance noise_cov = mne.compute_covariance(epochs, tmin=bfBaselineMin, tmax=bfBaselineMax, n_jobs = 4) data_cov = mne.compute_covariance(epochs, tmin=bfActiveMin, tmax=bfActiveMax, n_jobs = 4) # run LCMV beamformer filters = mne.beamformer.make_lcmv(epochs.info, forward, data_cov, reg=regularization, noise_cov=noise_cov, pick_ori='max-power') stc = mne.beamformer.apply_lcmv(evoked, filters) # crop beamformer result to times of interest stc.crop(bfActiveMin, bfActiveMax) # take absolute value of beamformer (to eliminate anti-phase issue) np.abs(stc.data, out=stc.data) # save ERB map niiFile = os.path.join(repDir, "".join(['full', cfg["file_io"]["file_ext"]["nifti_file"]])) mne.save_stc_as_volume(niiFile, stc, forward['src'], dest='surf', mri_resolution=False)
snr = 3.0 lambda2 = 1.0 / snr**2 method = "dSPM" # use dSPM method (could also be MNE or sLORETA) # Load data evoked = Evoked(fname_evoked, setno=0, baseline=(None, 0)) inverse_operator = read_inverse_operator(fname_inv) src = inverse_operator['src'] # Compute inverse solution stc = apply_inverse(evoked, inverse_operator, lambda2, method) stc.crop(0.0, 0.2) # Save result in a 4D nifti file img = mne.save_stc_as_volume( 'mne_%s_inverse.nii.gz' % method, stc, src, mri_resolution=False) # set to True for full MRI resolution data = img.get_data() # plot result (one slice) coronal_slice = data[:, 10, :, 60] pl.close('all') pl.imshow(np.ma.masked_less(coronal_slice, 8), cmap=pl.cm.Reds, interpolation='nearest') pl.colorbar() pl.contour(coronal_slice != 0, 1, colors=['black']) pl.xticks([]) pl.yticks([]) pl.show()
data_cov = mne.compute_covariance(epochs, tmin=0.04, tmax=0.15) # Run free orientation (vector) beamformer. Source orientation can be # restricted by setting pick_ori to 'max-power' (or 'normal' but only when # using a surface-based source space) stc = lcmv(evoked, forward, noise_cov, data_cov, reg=0.01, pick_ori=None) # Save result in stc files stc.save('lcmv-vol') stc.crop(0.0, 0.2) # Save result in a 4D nifti file img = mne.save_stc_as_volume( 'lcmv_inverse.nii.gz', stc, forward['src'], mri_resolution=False) # True for full MRI resolution # plot result (one slice) plt.close('all') data = img.get_data() coronal_slice = data[:, 10, :, 60] plt.figure() plt.imshow(np.ma.masked_less(coronal_slice, 1), cmap=plt.cm.Reds, interpolation='nearest') plt.colorbar() plt.contour(coronal_slice != 0, 1, colors=['black']) plt.xticks([]) plt.yticks([])
fname_evoked = data_path + '/MEG/sample/sample_audvis-ave.fif' snr = 3.0 lambda2 = 1.0 / snr ** 2 method = "dSPM" # use dSPM method (could also be MNE or sLORETA) # Load data evoked = Evoked(fname_evoked, setno=0, baseline=(None, 0)) inverse_operator = read_inverse_operator(fname_inv) src = inverse_operator['src'] # Compute inverse solution stc = apply_inverse(evoked, inverse_operator, lambda2, method) stc.crop(0.0, 0.2) # Save result in a 4D nifti file img = mne.save_stc_as_volume('mne_%s_inverse.nii.gz' % method, stc, src, mri_resolution=False) # set to True for full MRI resolution data = img.get_data() # plot result (one slice) coronal_slice = data[:, 10, :, 60] pl.close('all') pl.imshow(np.ma.masked_less(coronal_slice, 8), cmap=pl.cm.Reds, interpolation='nearest') pl.colorbar() pl.contour(coronal_slice != 0, 1, colors=['black']) pl.xticks([]) pl.yticks([]) pl.show()
# Apply this spatial filter to the evoked data. stc = apply_lcmv(evoked, filters, max_ori_out='signed') # take absolute values for plotting stc.data[:, :] = np.abs(stc.data) # Save result in stc files stc.save('lcmv-vol') # select time window (tmin, tmax) stc.crop(0.0, 0.0) # Save result in a 4D nifti file mne.save_stc_as_volume('lcmv_inverse.nii.gz', stc, forward['src'], mri_resolution=True) ############################################################################### # Load nifti data and reslice # isometric voxel size of 3 mm - reconsider for real data voxel_size = (3., 3., 3.) # number of iterations for each optimisation level niter_affine = [100, 100, 10] niter_sdr = [5, 5, 3] # load lcmv inverse img_vol = nib.load('lcmv_inverse.nii.gz')
stc.data.max(axis=1))[ts_show:]].T) plt.title(dfname + ' for %d largest sources' % abs(ts_show)) plt.xlabel('time (ms)') plt.ylabel('%s value ' % 'LCMV stc' + '@reg=%.2f' % reg) plt.show() stc.crop(0.0, stc.times[-1]) thresh = stc.data.max() * 2 / 100 timepoint = int(t_peak // stc.tstep - stc.times[0] // stc.tstep) img = mne.save_stc_as_volume('lcmv_stc.nii', stc, fwd['src'], dest='mri', mri_resolution=False) plot_stat_map( index_img(img, int(timepoint)), mrifile, draw_cross=True, threshold=thresh, title=dfname + '/ LCMV/ ' + 'reg=%.2f' % reg + '/ Vpeak=%.3f\n' % stc.data.max() + 'Tpeak=%.3fs' % t_peak + '/ Est_loc= [%.1f, %.1f, %.1f]' % tuple(est_loc) + '/ Loc_err= %.1f' % loc_err) os.remove('lcmv_stc.nii') fid = open(resultfile_lcmv, 'a+')
# Save result in stc files stc.save(op.join(datapath, subject, 'lcmv-vol')) stc.crop(0.0, 1.0) # plot dSPM time course in src space kwargs = dict(color='c', linestyle='--', linewidth=.5) f, ax = plt.subplots(1, 1, figsize=(8, 11)) mx = np.argmax(stc.data, axis=0) ax.plot(stc.times, stc.data[mx[:100], :].T) ax.autoscale(enable=True, axis='x', tight=True) ax.grid(True, which='major', axis='y', **kwargs) ax.set_xlabel('time (s)') ax.set_ylabel('strength') # Save result in a 4D nifti file img = mne.save_stc_as_volume(op.join(datapath, subject, 'lcmv_inverse.nii.gz',), stc, fwd['src'], mri_resolution=False) t1_fname = subjects_dir + '/fsaverage/mri/T1.mgz' # Plotting with nilearn idx = stc.time_as_index(0.5) plot_stat_map(index_img(img, idx), t1_fname, threshold=0.45, title='LCMV (t=%.3f s.)' % stc.times[idx]) # plot source time courses with the maximum peak amplitudes at idx plt.figure() plt.plot(stc.times, stc.data[np.argsort(np.max(stc.data[:, idx], axis=1))[-40:]].T) plt.xlabel('Time (ms)') plt.ylabel('LCMV value') plt.show()
def vol_source_loc(evoked, cov, fs_subj, study_path, plot=True): cond = evoked.info['description'] bem_fname = op.join(subjects_dir, fs_subj, 'bem', '%s-bem-sol.fif' % fs_subj) trans_fname = op.join(study_path, 'source_stim', subj, 'source_files', img_type, '%s_static-trans.fif' % fs_subj) mri_file = op.join(subjects_dir, subj, 'mri', 'T1.mgz') v_source = mne.setup_volume_source_space(subject=fs_subj, mri=mri_file, bem=bem_fname, subjects_dir=subjects_dir, pos=2.) fwd = mne.make_forward_solution( evoked.info, trans_fname, v_source, bem_fname, mindist=5.0, # ignore sources<=5mm from innerskull meg=False, eeg=True, n_jobs=2) mne.write_forward_solution( op.join(study_path, 'source_stim', subj, 'source_files', '%s_vol_source_space_2mm'), fwd) inv = mne.minimum_norm.make_inverse_operator(evoked.info, fwd, cov, loose=1, depth=1) method = "sLORETA" snr = 30. lambda2 = 1. / snr**2 stc = mne.minimum_norm.apply_inverse(evoked, inv, lambda2, method=method, pick_ori=None) stc.crop(-0.005, 0.005) from nilearn.plotting import plot_stat_map from nilearn.image import index_img import nilearn as ni nii_fname = op.join(study_path, 'source_stim', subj, 'source_files', img_type, 'stc', '%s_%s_stc.nii' % (subj, cond)) img = mne.save_stc_as_volume(nii_fname, stc.copy().crop(-0.003, 0.003), fwd['src'], dest='mri') t0_img = index_img(img, 3) act_coord = ni.plotting.find_xyz_cut_coords(t0_img) #act_coord = [57, 122, 87] thr = np.percentile(t0_img.get_data(), 99.9) st_map = plot_stat_map(t0_img, mri_file, threshold=thr, display_mode='ortho', cmap=plt.cm.plasma) st_map.add_markers(np.reshape(act_coord, (-1, 3)), marker_color='g', marker_size=50) fname_fig = op.join(study_path, 'source_stim', subj, 'figures', 'volume', '%s_%s_st_map.pdf' % (subj, cond)) st_map.savefig(fname_fig) dist_vol = euclidean()
vtx, _, trh = stcrh_label.center_of_mass('fsaverage') mnirh = mne.vertex_to_mni(vtx, 1, 'fsaverage')[0] testrh.append(mnirh) ############################################################################### # save as nifti src = mne.setup_source_space('fsaverage_tmp', spacing='ico5') # Export result as a 4D nifti object path = '/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG/GROUP/mne_python/Plot_STATS/RefPast_vs_RefPre_vs_RefFut'; stc_fname = (path + '/fmapMEEG_RefPast_vs_RefPre_vs_RefFut-rh.stc') stc = mne.read_source_estimate(stc_fname) fname = '/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG/GROUP/nifti/Refpast_RefPre_RefFut.nii') mne.save_stc_as_volume(fname, stc, src, dest='mri', mri_resolution=False)
def vol_source_loc(evoked, fwd, cov, fs_subj, method='sLORETA', plot=False): cond = evoked.info['description'] stim_coords = find_stim_coords(cond, subj, study_path) evo_crop = evoked.copy().crop(-0.003, 0.003) inv = mne.minimum_norm.make_inverse_operator(evoked.info, fwd, cov, loose=1, depth=0.8) snr = 30. lambda2 = 1. / snr ** 2 stc = mne.minimum_norm.apply_inverse(evo_crop, inv, lambda2, method=method, pick_ori=None) from nilearn.plotting import plot_stat_map from nilearn.image import index_img import nilearn as ni nii_fname = op.join(study_path, 'source_stim', subj, 'source_files', img_type, 'stc', '%s_%s_stc.nii' % (subj, cond)) img = mne.save_stc_as_volume(nii_fname, stc.copy().crop(-0.003, 0.003), fwd['src'], dest='mri', mri_resolution=True) mri_file = op.join(subjects_dir, fs_subj, 'mri', 'T1.mgz') from nibabel.affines import apply_affine mri = nib.load(mri_file) img_dat = img.get_data() stim_loc_vox = np.unravel_index(img_dat.argmax(), img_dat.shape) t_max = stim_loc_vox[-1] img_max = index_img(img, t_max) loc_coords = apply_affine(mri.affine, stim_loc_vox[:3]) dist = euclidean(stim_coords['scanner_RAS'], loc_coords) max_coords = ni.plotting.find_xyz_cut_coords(img_max, activation_threshold=99.95) print('Distance: %0.1f mm' % dist) if plot: thr = np.percentile(img_max.get_data(), 99.95) st_map = plot_stat_map(img_max, mri_file, threshold=thr, display_mode='ortho', cmap=plt.cm.plasma, cut_coords=max_coords) img_thr = ni.image.threshold_img(img_max, '99%') from scipy import linalg inv_aff = linalg.inv(mri.affine) stim_scan_coords = apply_affine(inv_aff, stim_loc_vox[:3]) img_thr_dat = img_thr.get_data() dat = img_max.get_data() plt.hist(dat[np.nonzero(dat)].flatten()) plot_stat_map(img_max, mri_file) # img_smo = ni.image.smooth_img(index_img(img, t_max), fwhm=50) # smo_dat = img_smo.get_data() # stim_loc_vox_smo = np.unravel_index(smo_dat.argmax(), smo_dat.shape) # loc_coords = apply_affine(mri.affine, stim_loc_vox_smo[:3]) # dist = euclidean(stim_coords['scanner_RAS'], loc_coords) # print('Distance: %0.1f mm' % dist) # # thr = np.percentile(img_smo.get_data(), 99.99) # st_map = plot_stat_map(img_smo, mri_file, threshold=thr, display_mode='ortho', cmap=plt.cm.plasma, # cut_coords=loc_coords) # fname_fig = op.join(study_path, 'source_stim', subj, 'figures', 'distributed', '%s_%s_vol.pdf' % (subj, cond)) # st_map.savefig(fname_fig) # plt.close() # # stc_dspm = mne.minimum_norm.apply_inverse(evo_crop, inv, lambda2=lambda2, # method='dSPM') # # Compute TF-MxNE inverse solution with dipole output # from mne.inverse_sparse import tf_mixed_norm, make_stc_from_dipoles # alpha_space = 50 # alpha_time = 0 # loose = 1 # depth = 0.2 # dipoles, residual = tf_mixed_norm( # evo_crop, fwd, cov, alpha_space, alpha_time, loose=loose, depth=depth, # maxit=200, tol=1e-6, weights=stc_dspm, weights_min=8., debias=True, # wsize=16, tstep=4, window=0.05, return_as_dipoles=True, # return_residual=True) # # stim_coords = find_stim_coords(cond, subj, study_path) # # import mne.transforms as tra # trans_fname = op.join(study_path, 'source_stim', subj, 'source_files', img_type, '%s_fid-trans.fif' % fs_subj) # trans = mne.read_trans(trans_fname) # # stim_point = stim_coords['surf'] # get point for plot in mm # #dip.pos[np.argmax(dip.gof)] = tra.apply_trans(surf_to_head, stim_coords['surf_ori']/1e3) # check stim loc (apply affine in m) # # idx = np.argmax([np.max(np.abs(dip.amplitude)) for dip in dipoles]) # dip_surf = tra.apply_trans(trans['trans'], dipoles[idx].pos[0]) * 1e3 # transform from head to surface # dist_surf = euclidean(dip_surf, stim_point) # compute distance in surface space # print(dist_surf) # # plot_dipole_amplitudes(dipoles) # # # Plot dipole location of the strongest dipole with MRI slices # # plot_dipole_locations(dipoles[idx], fwd['mri_head_t'], subj, # subjects_dir=subjects_dir, mode='orthoview', # idx='amplitude') return dist
dSPM = True # Load data evoked = Evoked(fname_evoked, setno=setno, baseline=(None, 0)) inverse_operator = read_inverse_operator(fname_inv) src = inverse_operator['src'] # Compute inverse solution # default method='dSPM' (dynamical Statistical Parametric Mapping) # other options: MNE (mininum norm) or sLORETA (standardized low resolution brain electromagnetic tomography) stc = apply_inverse(evoked, inverse_operator, lambda2, dSPM) #stc.crop(0.0, 0.2) #why!? (10x bigger otherwise) # Save result in a 4D nifti file # saved as e.g. /data/Luna1/Multimodal/ANTI/10892/MEG/10892_anti_Correct_ave.nii.gz img = mne.save_stc_as_volume(data_path+'/'+subject+'/MEG/'+subject+'_'+args['output']+'.nii.gz', stc, src) # save_stc_as_volume: http://www.martinos.org/mne/generated/mne.save_stc_as_volume.html # mri_resolution=False (default) # set to True for full MRI resolution # dest='mri' (default) # 'mri': volume is defined in the coordinate system of the original T1 image. # 'surf': coordinate system of the FreeSurfer surface is used (Surface RAS). ## plot result (one slice) #data = img.get_data() #coronal_slice = data[:, 10, :, 60] #pl.close('all') #pl.imshow(np.ma.masked_less(coronal_slice, 8), cmap=pl.cm.Reds, # interpolation='nearest') #pl.colorbar()
data_cov = mne.compute_covariance(epochs, tmin=0.04, tmax=0.15) # Run free orientation (vector) beamformer. Source orientation can be # restricted by setting pick_ori to 'max-power' (or 'normal' but only when # using a surface-based source space) stc = lcmv(evoked, forward, noise_cov, data_cov, reg=0.01, pick_ori=None) # Save result in stc files stc.save("lcmv-vol") stc.crop(0.0, 0.2) # Save result in a 4D nifti file img = mne.save_stc_as_volume( "lcmv_inverse.nii.gz", stc, forward["src"], mri_resolution=False ) # True for full MRI resolution # plot result (one slice) plt.close("all") data = img.get_data() coronal_slice = data[:, 10, :, 60] plt.figure() plt.imshow(np.ma.masked_less(coronal_slice, 1), cmap=plt.cm.Reds, interpolation="nearest") plt.colorbar() plt.contour(coronal_slice != 0, 1, colors=["black"]) plt.xticks([]) plt.yticks([]) # plot source time courses with the maximum peak amplitudes plt.figure()