def surf_stat_maps(self, data, data_type, map_index): data, title, threshold, output_folder = self.prepare_plots( data, data_type, map_index, "Surf_Stat_Maps") fsaverage = datasets.fetch_surf_fsaverage() texture = surface.vol_to_surf(data, fsaverage.pial_left) plotting.plot_surf_stat_map( fsaverage.infl_left, texture, hemi='left', view='lateral', title=title, colorbar=True, threshold=threshold, bg_map=fsaverage.sulc_left, bg_on_data=True, cmap='Spectral', output_file=(output_folder + 'feature_' + str(map_index) + '-left-lateral-' + self.category + '_category.png')) plotting.plot_surf_stat_map( fsaverage.infl_left, texture, hemi='left', view='medial', title=title, colorbar=True, threshold=threshold, bg_map=fsaverage.sulc_left, bg_on_data=True, cmap='Spectral', output_file=(output_folder + 'feature_' + str(map_index) + '-left-medial-' + self.category + '_category.png')) texture = surface.vol_to_surf(data, fsaverage.pial_right) plotting.plot_surf_stat_map( fsaverage.infl_right, texture, hemi='right', view='lateral', title=title, colorbar=True, threshold=threshold, bg_map=fsaverage.sulc_right, bg_on_data=True, cmap='Spectral', output_file=(output_folder + 'feature_' + str(map_index) + '-right-lateral-' + self.category + '_category.png')) plotting.plot_surf_stat_map( fsaverage.infl_right, texture, hemi='right', view='medial', title=title, colorbar=True, threshold=threshold, bg_map=fsaverage.sulc_right, bg_on_data=True, cmap='Spectral', output_file=(output_folder + 'feature_' + str(map_index) + '-right-medial-' + self.category + '_category.png'))
def volumeToSurface(image, interpolation='linear'): fsaverageL = r"E:\brain\BNatlas\BN_Atlas_freesurfer\fsaverage\fsaverage_LR32k\fsaverage.L.inflated.32k_fs_LR.surf.gii" fsaverageR = r"E:\brain\BNatlas\BN_Atlas_freesurfer\fsaverage\fsaverage_LR32k\fsaverage.R.inflated.32k_fs_LR.surf.gii" textureL = surface.vol_to_surf( image, fsaverageL, inner_mesh= r"E:\brain\BNatlas\BN_Atlas_freesurfer\fsaverage\fsaverage_LR32k\fsaverage.L.white.32k_fs_LR.surf.gii" ) textureR = surface.vol_to_surf( image, fsaverageR, inner_mesh= r"E:\brain\BNatlas\BN_Atlas_freesurfer\fsaverage\fsaverage_LR32k\fsaverage.R.white.32k_fs_LR.surf.gii" ) #textureL = surface.vol_to_surf(image,fsaverageL,radius=4,interpolation=interpolation,kind='line',mask_img='Mask.nii') #textureR = surface.vol_to_surf(image,fsaverageR,radius=4,interpolation=interpolation,kind='line',mask_img='Mask.nii') newL = nib.GiftiImage( header=nib.load(r"E:\brain\GS\surface\NC_tmap.nii.L.func.gii").header) newR = nib.GiftiImage( header=nib.load(r"E:\brain\GS\surface\NC_tmap.nii.R.func.gii").header) dataArrayL = nib.gifti.gifti.GiftiDataArray(textureL.astype(np.float32)) dataArrayR = nib.gifti.gifti.GiftiDataArray(textureR.astype(np.float32)) newL.add_gifti_data_array(dataArrayL) newR.add_gifti_data_array(dataArrayR) return newL, newR
def _check_vol_to_surf_results(img, mesh): mni_mask = datasets.load_mni152_brain_mask() for kind, interpolation, mask_img in itertools.product( ['ball', 'line'], ['linear', 'nearest'], [mni_mask, None]): proj_1 = vol_to_surf(img, mesh, kind=kind, interpolation=interpolation, mask_img=mask_img) assert_true(proj_1.ndim == 1) img_rot = image.resample_img(img, target_affine=rotation( np.pi / 3., np.pi / 4.)) proj_2 = vol_to_surf(img_rot, mesh, kind=kind, interpolation=interpolation, mask_img=mask_img) # The projection values for the rotated image should be close # to the projection for the original image diff = np.abs(proj_1 - proj_2) / np.abs(proj_1) assert_true(np.mean(diff[diff < np.inf]) < .03) img_4d = image.concat_imgs([img, img]) proj_4d = vol_to_surf(img_4d, mesh, kind=kind, interpolation=interpolation, mask_img=mask_img) nodes, _ = surface.load_surf_mesh(mesh) assert_array_equal(proj_4d.shape, [nodes.shape[0], 2]) assert_array_almost_equal(proj_4d[:, 0], proj_1, 3)
def plot_data(data,affine,plot_title,thresh): minval = np.min(data) maxval = np.max(data) img = nib.Nifti1Image(data,affine) img.header["cal_min"] = minval img.header["cal_max"] = maxval fsaverage = datasets.fetch_surf_fsaverage() texture_right = surface.vol_to_surf(img, fsaverage.pial_right) texture_left = surface.vol_to_surf(img, fsaverage.pial_left) plotting.plot_surf_stat_map(fsaverage.infl_right, texture_right, hemi='right', title=plot_title, colorbar=True, threshold=thresh, bg_map=fsaverage.sulc_right) plotting.plot_surf_stat_map(fsaverage.infl_left, texture_left, hemi='left', title=plot_title, threshold=thresh, bg_map=fsaverage.sulc_left) plt.show()
def plot_data(data, affine, thresh): minval = np.min(data) maxval = np.max(data) img = nib.Nifti1Image(data, affine) img.header["cal_min"] = minval img.header["cal_max"] = maxval fsaverage = datasets.fetch_surf_fsaverage() texture_right = surface.vol_to_surf(img, fsaverage.pial_right) texture_left = surface.vol_to_surf(img, fsaverage.pial_left) # plot right lateral plotting.plot_surf_stat_map(fsaverage.infl_right, texture_right, hemi='right', view='lateral', title="right lateral", threshold=thresh, bg_map=fsaverage.sulc_right) plt.tight_layout() # plot left lateral plotting.plot_surf_stat_map(fsaverage.infl_left, texture_left, hemi='left', view='lateral', title="left lateral", threshold=thresh, bg_map=fsaverage.sulc_left) plt.tight_layout() # plot right medial plotting.plot_surf_stat_map(fsaverage.infl_right, texture_right, hemi='right', view='medial', title="right medial", threshold=thresh, bg_map=fsaverage.sulc_right) plt.tight_layout() # plot left medial plotting.plot_surf_stat_map(fsaverage.infl_left, texture_left, hemi='left', view='medial', title="left medial", threshold=thresh, bg_map=fsaverage.sulc_left) plt.tight_layout() plt.show()
def main(argv=None): args = get_parser().parse_args(argv) output_dir = op.join(args.dset, 'derivatives', args.deriv, args.sub, args.ses) os.makedirs(output_dir, exist_ok=True) nii_files = glob( op.join(args.dset, 'derivatives', '3dTproject_denoise_acompcor_csfwm+12mo+0.35mm', args.sub, args.ses, '*.nii.gz')) for tmp_nii_file in nii_files: print(tmp_nii_file) imgs = nib.load(tmp_nii_file) fsaverage = fetch_surf_fsaverage(mesh='fsaverage5') mask = compute_background_mask(imgs) surf_lh = surface.vol_to_surf(imgs, fsaverage.pial_left, radius=24, interpolation='nearest', kind='ball', n_samples=None, mask_img=mask) surf_rh = surface.vol_to_surf(imgs, fsaverage.pial_right, radius=24, interpolation='nearest', kind='ball', n_samples=None, mask_img=mask) time_series = np.transpose(np.vstack((surf_lh, surf_rh))) correlation = ConnectivityMeasure(kind='correlation') time_series = correlation.fit_transform([time_series])[0] plotting.plot_matrix(time_series, figure=(10, 8)) plt.savefig( op.join( output_dir, '{0}-correlation_matrix.png'.format( op.basename(tmp_nii_file).split('.')[0]))) plt.close() with open( op.join( output_dir, '{0}-correlation_matrix.pkl'.format( op.basename(tmp_nii_file).split('.')[0])), 'wb') as fo: pickle.dump(time_series, fo)
def membership_to_rois(template, mesh, memb, **kwargs): ''' Input: template: a nibabel.nifti1.Nifti1Image object mesh: a string of a mesh, or a list of two np.array with vert and faces memb: a np.array of integers of the parcel membership ''' from copy import copy template2 = copy(template) radius = kwargs.get('radius', 0.01) # Put the specific node module index inside the atlas nifti, thus changing # the volume content indices = [] all_parcels = np.unique(template2.get_fdata().flatten()).astype(np.int32) # find the indices of the voxels of a given parcel # since it's sorted we will exclude the 0 parcel for parcel in all_parcels[1:]: # avoid parcel 0 which is empty space i, j, k = np.where(template2.get_fdata(caching='fill') == parcel) indices.append((i, j, k)) # # Put the membership as from memb in those voxels for parcel in all_parcels[1:]: # set the value to the voxesl as the parcel membership i, j, k = indices[parcel - 1][0], indices[parcel - 1][1], indices[parcel - 1][2] template2.get_data(caching='fill')[i, j, k] = memb[parcel - 1] from nilearn.surface import vol_to_surf memb_rois = surface.vol_to_surf(template2, mesh, interpolation='nearest', radius=radius) return memb_rois
def full_brain_info(stat_map, mesh=None, threshold=None, cmap=plotting.cm.cold_hot): info = {} if mesh is None: mesh = datasets.fetch_surf_fsaverage5() # mesh = load_fsaverage() surf_maps = [ surface.vol_to_surf(stat_map, mesh['pial_{}'.format(h)]) for h in ['left', 'right'] ] colors, cmax, cmap, norm, at = colorscale(cmap, np.asarray(surf_maps).ravel(), threshold) for hemi, surf_map in zip(['left', 'right'], surf_maps): pial = mesh['pial_{}'.format(hemi)] sulc_depth_map = surface.load_surf_data(mesh['sulc_{}'.format(hemi)]) sulc_depth_map -= sulc_depth_map.min() sulc_depth_map /= sulc_depth_map.max() info['pial_{}'.format(hemi)] = to_plotly(pial) info['inflated_{}'.format(hemi)] = to_plotly( mesh['infl_{}'.format(hemi)]) vertexcolor = cmap(norm(surf_map).data) if threshold is not None: anat_color = cm.get_cmap('Greys')(sulc_depth_map) vertexcolor[np.abs(surf_map) < at] = anat_color[ np.abs(surf_map) < at] vertexcolor = np.asarray(vertexcolor * 255, dtype='uint8') info['vertexcolor_{}'.format(hemi)] = [ '#{:02x}{:02x}{:02x}'.format(*row) for row in vertexcolor ] info["cmin"], info["cmax"] = -cmax, cmax return info, colors
def plot_roi_img_surf(surf_img, saving_path, plot_name, mask=None, labels=None, inflated=False, compute_surf=True, colorbar=True, **kwargs): fsaverage = datasets.fetch_surf_fsaverage() if compute_surf: surf_img = vol_to_surf(surf_img, fsaverage[kwargs['surf_mesh']], interpolation='nearest', mask_img=mask) surf_img[np.isnan(surf_img)] = -2 if labels is not None: surf_img = np.round(surf_img) surf_img += 2 if saving_path: plt.close('all') plt.hist(surf_img, bins=50) plt.title(plot_name) plt.savefig(saving_path + "hist_{}.png".format(plot_name)) plt.close('all') if inflated: kwargs['surf_mesh'] = 'infl_left' if 'left' in kwargs['surf_mesh_type'] else 'infl_right' disp = plotting.plot_surf_roi( surf_mesh=fsaverage[kwargs['surf_mesh']], roi_map=surf_img, hemi=kwargs['hemi'], view=kwargs['view'], bg_map=fsaverage[kwargs['bg_map']], bg_on_data=kwargs['bg_on_data'], darkness=kwargs['darkness'], colorbar=colorbar) if saving_path: disp.savefig(saving_path + plot_name + '_{}_{}_{}.png'.format(kwargs['surf_mesh_type'], kwargs['hemi'], kwargs['view'])) plotting.show()
def vol_2surf(self, radius=.3): for param, img in self.voxel_regressions.items(): for hemisphere in ['L', 'R']: pial = join( self.epi_dir, 'completed_preprocessed', self.subject, 'fmriprep', self.subject, 'anat', '{0}_T1w_pial.{1}.surf.gii'.format(self.subject, hemisphere)) surface = vol_to_surf(img, pial, radius=radius, kind='line') self.surface_textures.append(surface) slu.mkdir_p(join(self.out_dir, 'surface_textures')) pd.DataFrame(surface, columns=['coef_', 'intercept_', 'r2_score', 'mean_squared_error']).\ to_csv(join(self.out_dir, 'surface_textures', '{0}_{1}_{2}_{3}.csv'.format(self.subject, self.session, param, hemisphere)))
def surface_plots(self, perf_img): print("Creating surface plots") figure, axes = plt.subplots(2, 2, subplot_kw={"projection": "3d"}, figsize=(12, 12)) axes = axes.ravel() big_fsaverage = datasets.fetch_surf_fsaverage("fsaverage") cnt = 0 for hemi, infl, sulc, pial in [ ( "left", big_fsaverage.infl_left, big_fsaverage.sulc_left, big_fsaverage.pial_left, ), ( "right", big_fsaverage.infl_right, big_fsaverage.sulc_right, big_fsaverage.pial_right, ), ]: print("Hemi {}".format(hemi)) big_texture = surface.vol_to_surf(perf_img, pial, interpolation="nearest") for view in ["lateral", "medial"]: print(" View {}".format(view)) if cnt == 3: output_file = os.path.join( self.folder, "importance_scores_surface.png") else: output_file = None plotting.plot_surf_stat_map( infl, big_texture, hemi=hemi, colorbar=True, title="{} hemisphere {} view".format(hemi, view), threshold=0.0001, bg_map=sulc, view=view, output_file=output_file, axes=axes[cnt], ) cnt += 1
def vol_2surf(self, radius=.3): for param, img in self.voxel_regressions.items(): for hemisphere in ['L', 'R']: pial = join( self.flex_dir, 'fmri', 'completed_preprocessed', self.subject, 'fmriprep', self.subject, 'anat', '{0}_T1w_pial.{1}.surf.gii'.format(self.subject, hemisphere)) surface = vol_to_surf(img, pial, radius=radius, kind='line') self.surface_textures[param][hemisphere] = pd.DataFrame( surface, columns=[ 'coef_', 'intercept_', 'r2_score', 'mean_squared_error' ])
def full_brain_info(volume_img, mesh='fsaverage5', threshold=None, cmap=cm.cold_hot, black_bg=False, symmetric_cmap=True, vmax=None, vmin=None, vol_to_surf_kwargs={}): """ Project 3D map on cortex; prepare info to plot both hemispheres. This computes the dictionary that gets inserted in the web page, which contains encoded meshes, colors, min and max values, and background color. """ info = {} mesh = surface.surface._check_mesh(mesh) surface_maps = { h: surface.vol_to_surf(volume_img, mesh['pial_{}'.format(h)], inner_mesh=mesh.get('white_{}'.format(h), None), **vol_to_surf_kwargs) for h in ['left', 'right'] } colors = colorscale(cmap, np.asarray(list(surface_maps.values())).ravel(), threshold, symmetric_cmap=symmetric_cmap, vmax=vmax, vmin=vmin) for hemi, surf_map in surface_maps.items(): bg_map = surface.load_surf_data(mesh['sulc_{}'.format(hemi)]) info['pial_{}'.format(hemi)] = mesh_to_plotly( mesh['pial_{}'.format(hemi)]) info['inflated_{}'.format(hemi)] = mesh_to_plotly( mesh['infl_{}'.format(hemi)]) info['vertexcolor_{}'.format(hemi)] = _get_vertexcolor( surf_map, colors['cmap'], colors['norm'], colors['abs_threshold'], bg_map) info["cmin"], info["cmax"] = float(colors['vmin']), float(colors['vmax']) info['black_bg'] = black_bg info['full_brain_mesh'] = True info['colorscale'] = colors['colors'] return info
def _check_vol_to_surf_results(img, mesh): mni_mask = datasets.load_mni152_brain_mask() for kind, interpolation, mask_img in itertools.product( ['ball', 'line'], ['linear', 'nearest'], [mni_mask, None]): proj_1 = vol_to_surf( img, mesh, kind=kind, interpolation=interpolation, mask_img=mask_img) assert_true(proj_1.ndim == 1) img_rot = image.resample_img( img, target_affine=rotation(np.pi / 3., np.pi / 4.)) proj_2 = vol_to_surf( img_rot, mesh, kind=kind, interpolation=interpolation, mask_img=mask_img) # The projection values for the rotated image should be close # to the projection for the original image diff = np.abs(proj_1 - proj_2) / np.abs(proj_1) assert_true(np.mean(diff[diff < np.inf]) < .03) img_4d = image.concat_imgs([img, img]) proj_4d = vol_to_surf( img_4d, mesh, kind=kind, interpolation=interpolation, mask_img=mask_img) nodes, _ = surface.load_surf_mesh(mesh) assert_array_equal(proj_4d.shape, [nodes.shape[0], 2]) assert_array_almost_equal(proj_4d[:, 0], proj_1, 3)
def add_surf_map(niimg, sides=['left', 'right'], selected=False, threshold=None, **kwargs): """ Project a volumetric data and plot it on the corresponding fsaverage surface. The kwargs are passed to mlab.triangular_mesh """ actors = dict() for side in sides: data = surface.vol_to_surf(niimg, fsaverage['pial_%s' % side]) this_actor = plot_on_surf(data, selected=selected, sides=[side, ], threshold=threshold, **kwargs) actors[side] = this_actor[side] return actors
def extract_correlation_hemi(self, nifti_image, output_file, mesh, hemi='map_left'): """ Input params: - hemi (hemisphere) = 'map_left' or 'map_right' - mesh : 'fsaverage.infl_left' 'fsaverage.infl_right' 'fsaverage.pial_left' 'fsaverage.pial_right' 'fsaverage.sulc_left' 'fsaverage.sulc_right' Output param: - correlation matrix and its zFisher values - Save the correlation matrix to csv file """ # extract surface data from nifti image ################### surface_data = surface.vol_to_surf(nifti_image, surf_mesh=mesh) timeseries = surface.load_surf_data(surface_data) # fill Nan value with 0 and infinity with large finite numbers timeseries = np.nan_to_num(timeseries) # get destrieux atlas ###################################### destrieux_atlas = datasets.fetch_atlas_surf_destrieux() labels = destrieux_atlas['labels'] # get labels parcellation = destrieux_atlas[hemi] # get parcellation # convert timeseries surface to 2D matrix where each column is a ROI rois = [] for i in range(len(labels)): pcc_labels = np.where(parcellation == i)[0] # each parcellation to 1D matrix seed_timeseries = np.mean(timeseries[pcc_labels], axis=0) rois.append(np.array(seed_timeseries)) rois = np.array(rois).T rois = np.nan_to_num(rois) # extract correlation matrix correlation_measure = ConnectivityMeasure(kind='correlation') corr_rois = correlation_measure.fit_transform([rois])[0] corr_rois_z = np.arctanh(corr_rois) # normalize to z-fisher # save the correlation to csv df = pd.DataFrame(corr_rois_z) df.to_csv(output_file, index=False, header=None) return corr_rois, corr_rois_z
def plot_brain_saliences(custom_roi, minval=0, maxval=None, figpath=None, cbar=False, cmap=None): mpl.rcParams.update(mpl.rcParamsDefault) if cmap is None: cmap = 'coolwarm' fsaverage = datasets.fetch_surf_fsaverage() orders = [('medial', 'left'), ('medial', 'right'), ('lateral', 'left'), ('lateral', 'right')] fig, ax = plt.subplots(nrows=2, ncols=2, figsize=(8.0, 6.0), dpi=300, frameon=False, sharex=True, sharey=True, subplot_kw={'projection': '3d'}) fig.subplots_adjust(hspace=0., wspace=0.00005) axes_list = fig.axes for index, order in enumerate(orders): view = order[0] hemi = order[1] texture = surface.vol_to_surf(custom_roi, fsaverage['pial_%s' % hemi]) plotting.plot_surf_roi(fsaverage['infl_%s' % hemi], texture, cmap=cmap, hemi=hemi, view=view, bg_on_data=True, axes=axes_list[index], bg_map=fsaverage['sulc_%s' % hemi], vmin=minval, vmax=maxval, output_file=figpath, symmetric_cbar=False, figure=fig, darkness=.5, colorbar=cbar) plt.clf()
def mni_to_fsaverage(self): ''' Extract surface data (fsaverage) from MNI152-nifti Uses nilearn.vol_to_surf: https://nilearn.github.io/modules/generated/nilearn.surface.vol_to_surf.html ''' fs_average = datasets.fetch_surf_fsaverage(mesh='fsaverage') for param, img in self.voxel_regressions.items(): for hemisphere, hemi in {'L': 'left', 'R': 'right'}.items(): surface = vol_to_surf(img, fs_average['pial_{}'.format(hemi)], radius=.3, kind='line') self.surface_textures[param][hemisphere] = pd.DataFrame( surface, columns=[ 'coef_', 'intercept_', 'r2_score', 'mean_squared_error' ])
def vol_2surf(self): ''' Extract surface data (subject surface) from subject-specific T1w-nifti Uses nilearn.vol_to_surf: https://nilearn.github.io/modules/generated/nilearn.surface.vol_to_surf.html ''' for param, img in self.voxel_regressions.items(): for hemisphere in ['L', 'R']: pial = join( self.flex_dir, 'fmri', 'completed_preprocessed', self.subject, 'fmriprep', self.subject, 'anat', '{0}_T1w_pial.{1}.surf.gii'.format(self.subject, hemisphere)) surface = vol_to_surf(img, pial, radius=.3, kind='line') self.surface_textures[param][hemisphere] = pd.DataFrame( surface, columns=[ 'coef_', 'intercept_', 'r2_score', 'mean_squared_error' ])
def surface_plots(self, perf_img): print('Creating surface plots') figure, axes = plt.subplots(2, 2, subplot_kw={'projection': '3d'}, figsize=(12, 12)) axes = axes.ravel() big_fsaverage = datasets.fetch_surf_fsaverage('fsaverage') cnt = 0 for hemi, infl, sulc, pial in [ ('left', big_fsaverage.infl_left, big_fsaverage.sulc_left, big_fsaverage.pial_left), ('right', big_fsaverage.infl_right, big_fsaverage.sulc_right, big_fsaverage.pial_right) ]: print('Hemi {}'.format(hemi)) big_texture = surface.vol_to_surf(perf_img, pial, interpolation='nearest') for view in ['lateral', 'medial']: print(' View {}'.format(view)) if cnt == 3: output_file = os.path.join( self.folder, 'importance_scores_surface.png') else: output_file = None plotting.plot_surf_stat_map( infl, big_texture, hemi=hemi, colorbar=True, title='{} hemisphere {} view'.format(hemi, view), threshold=0.0001, bg_map=sulc, view=view, output_file=output_file, axes=axes[cnt]) cnt += 1
def to_three(mesh, stat_map, sample_mesh=None): if sample_mesh is None: sample_mesh = mesh mesh = surface.load_surf_mesh(mesh) coords = mesh[0][mesh[1].ravel()] surf_stat_map = surface.vol_to_surf(stat_map, sample_mesh) surf_stat_map -= surf_stat_map.min() surf_stat_map /= surf_stat_map.max() colors = cm.cold_hot(surf_stat_map[mesh[1].ravel()])[:, :3] center = list(map(float, mesh[0].mean(axis=0))) center = {'x': center[0], 'y': center[1], 'z': center[2]} vertices = np.asarray(coords.ravel(), dtype='<f4') # vertices = list(map(float, coords.ravel())) col = list(map(float, colors.ravel())) return { 'INSERT_VERTICES_HERE': base64.b64encode( vertices.tobytes()).decode('utf-8'), #json.dumps(vertices), 'INSERT_COLORS_HERE': json.dumps(col), 'INSERT_CENTER_POSITION_HERE': json.dumps(center) }
stat_img2 = my_images template_brain = 'B3' b_obj_proj_ll = BrainObj(template_brain, hemisphere='left', translucent=False) b_obj_proj_lr = BrainObj(template_brain, hemisphere='left', translucent=False) b_obj_proj_rr = BrainObj(template_brain, hemisphere='right', translucent=False) b_obj_proj_rl = BrainObj(template_brain, hemisphere='right', translucent=False) meshll = [b_obj_proj_ll.vertices, b_obj_proj_ll.faces] meshlr = [b_obj_proj_lr.vertices, b_obj_proj_lr.faces] meshrr = [b_obj_proj_rr.vertices, b_obj_proj_rr.faces] meshrl = [b_obj_proj_rl.vertices, b_obj_proj_rl.faces] texturell = surface.vol_to_surf(stat_img2, meshll) texturelr = surface.vol_to_surf(stat_img2, meshlr) texturerr = surface.vol_to_surf(stat_img2, meshrr) texturerl = surface.vol_to_surf(stat_img2, meshrl) texturell = texturell.ravel() texturelr = texturelr.ravel() texturerr = texturerr.ravel() texturerl = texturerl.ravel() b_obj_proj_ll.add_activation(texturell, hemisphere='left', cmap='hot_r', vmin=0, vmax=1, clim=(0, 1))
stat_img = motor_images.images[0] ############################################################################## # Get a cortical mesh # ------------------- fsaverage = datasets.fetch_surf_fsaverage() ############################################################################## # Sample the 3D data around each node of the mesh # ----------------------------------------------- from nilearn import surface texture = surface.vol_to_surf(stat_img, fsaverage.pial_right) ############################################################################## # Plot the result # --------------- from nilearn import plotting plotting.plot_surf_stat_map(fsaverage.infl_right, texture, hemi='right', title='Surface right hemisphere', colorbar=True, threshold=1., bg_map=fsaverage.sulc_right) ############################################################################## # Plot 3D image for comparison # ----------------------------
def plot_img_on_surf(stat_map, surf_mesh='fsaverage5', mask_img=None, hemispheres=['left', 'right'], inflate=False, views=['lateral', 'medial'], output_file=None, title=None, colorbar=True, vmax=None, threshold=None, cmap='cold_hot', aspect_ratio=1.4, **kwargs): """Convenience function to plot multiple views of plot_surf_stat_map in a single figure. It projects stat_map into meshes and plots views of left and right hemispheres. The *views* argument defines the views that are shown. This function returns the fig, axes elements from matplotlib unless kwargs sets and output_file, in which case nothing is returned. Parameters ---------- stat_map : str or 3D Niimg-like object See http://nilearn.github.io/manipulating_images/input_output.html surf_mesh : str, dict, or None, optional If str, either one of the two: 'fsaverage5': the low-resolution fsaverage5 mesh (10242 nodes) 'fsaverage': the high-resolution fsaverage mesh (163842 nodes) If dict, a dictionary with keys: ['infl_left', 'infl_right', 'pial_left', 'pial_right', 'sulc_left', 'sulc_right'], where values are surface mesh geometries as accepted by plot_surf_stat_map. Default='fsaverage5'. mask_img : Niimg-like object or None, optional The mask is passed to vol_to_surf. Samples falling out of this mask or out of the image are ignored during projection of the volume to the surface. If ``None``, don't apply any mask. inflate : bool, optional If True, display images in inflated brain. If False, display images in pial surface. Default=False. views : list of strings, optional A list containing all views to display. The montage will contain as many rows as views specified by display mode. Order is preserved, and left and right hemispheres are shown on the left and right sides of the figure. Default=['lateral', 'medial']. hemispheres : list of strings, optional Hemispheres to display. Default=['left', 'right']. output_file : str, optional The name of an image file to export plot to. Valid extensions are: *.png*, *.pdf*, *.svg*. If output_file is not None, the plot is saved to a file, and the display is closed. Return value is None. title : str, optional Place a title on the upper center of the figure. colorbar : bool, optional If *True*, a symmetric colorbar of the statistical map is displayed. Default=True. vmax : float, optional Upper bound for plotting of stat_map values. threshold : float, optional If None is given, the image is not thresholded. If a number is given, it is used to threshold the image, values below the threshold (in absolute value) are plotted as transparent. cmap : str, optional The name of a matplotlib or nilearn colormap. Default='cold_hot'. kwargs : dict, optional keyword arguments passed to plot_surf_stat_map. See Also -------- nilearn.datasets.fetch_surf_fsaverage : For surface data object to be used as the default background map for this plotting function. nilearn.surface.vol_to_surf : For info on the generation of surfaces. nilearn.plotting.plot_surf_stat_map : For info on kwargs options accepted by plot_img_on_surf. """ for arg in ('figure', 'axes'): if arg in kwargs: raise ValueError(('plot_img_on_surf does not' ' accept %s as an argument' % arg)) stat_map = check_niimg_3d(stat_map, dtype='auto') modes = _check_views(views) hemis = _check_hemispheres(hemispheres) surf_mesh = _check_mesh(surf_mesh) mesh_prefix = "infl" if inflate else "pial" surf = { 'left': surf_mesh[mesh_prefix + '_left'], 'right': surf_mesh[mesh_prefix + '_right'], } texture = { 'left': vol_to_surf(stat_map, surf_mesh['pial_left'], mask_img=mask_img), 'right': vol_to_surf(stat_map, surf_mesh['pial_right'], mask_img=mask_img) } figsize = plt.figaspect(len(modes) / (aspect_ratio * len(hemispheres))) fig, axes = plt.subplots(nrows=len(modes), ncols=len(hemis), figsize=figsize, subplot_kw={'projection': '3d'}) axes = np.atleast_2d(axes) if len(hemis) == 1: axes = axes.T for index_mode, mode in enumerate(modes): for index_hemi, hemi in enumerate(hemis): bg_map = surf_mesh['sulc_%s' % hemi] plot_surf_stat_map( surf[hemi], texture[hemi], view=mode, hemi=hemi, bg_map=bg_map, axes=axes[index_mode, index_hemi], colorbar=False, # Colorbar created externally. vmax=vmax, threshold=threshold, cmap=cmap, **kwargs) for ax in axes.flatten(): # We increase this value to better position the camera of the # 3D projection plot. The default value makes meshes look too small. ax.dist = 6 if colorbar: sm = _colorbar_from_array(image.get_data(stat_map), vmax, threshold, kwargs, cmap=get_cmap(cmap)) cbar_ax = fig.add_subplot(32, 1, 32) fig.colorbar(sm, cax=cbar_ax, orientation='horizontal') fig.subplots_adjust(wspace=-0.02, hspace=0.0) if title is not None: fig.suptitle(title) if output_file is not None: fig.savefig(output_file) plt.close(fig) else: return fig, axes
# Project the fMRI image to the surface # ------------------------------------- # # For this we need to get a mesh representing the geometry of the # surface. We could use an individual mesh, but we first resort to a # standard mesh, the so-called fsaverage5 template from the FreeSurfer # software. import nilearn fsaverage = nilearn.datasets.fetch_surf_fsaverage() ######################################################################### # The projection function simply takes the fMRI data and the mesh. # Note that those correspond spatially, are they are both in MNI space. from nilearn import surface texture = surface.vol_to_surf(fmri_img, fsaverage.pial_right) ######################################################################### # Perform first level analysis # ---------------------------- # # This involves computing the design matrix and fitting the model. # We start by specifying the timing of fMRI frames. import numpy as np n_scans = texture.shape[1] frame_times = t_r * (np.arange(n_scans) + .5) ######################################################################### # Create the design matrix. #
######################################################################### # The projection function simply takes the fMRI data and the mesh. # Note that those correspond spatially, are they are bothin MNI space. import numpy as np from nilearn import surface from nistats.design_matrix import make_first_level_design_matrix from nistats.first_level_model import run_glm from nistats.contrasts import compute_contrast ######################################################################### # Empty lists in which we are going to store activation values. z_scores_right = [] z_scores_left = [] for (fmri_img, confound, events) in zip( models_run_imgs, models_confounds, models_events): texture = surface.vol_to_surf(fmri_img[0], fsaverage.pial_right) n_scans = texture.shape[1] frame_times = t_r * (np.arange(n_scans) + .5) # Create the design matrix # # We specify an hrf model containing Glover model and its time derivative # the drift model is implicitly a cosine basis with period cutoff 128s. design_matrix = make_first_level_design_matrix( frame_times, events=events[0], hrf_model='glover + derivative', add_regs=confound[0]) # contrast_specification contrast_values = (design_matrix.columns == 'language') * 1.0 -\ (design_matrix.columns == 'string')
y, session = y[condition_mask], session[condition_mask] ######################################################################### # Surface bold response # ---------------------- from nilearn import datasets, surface from sklearn import neighbors # Fetch a coarse surface of the left hemisphere only for speed fsaverage = datasets.fetch_surf_fsaverage(mesh='fsaverage5') hemi = 'left' # Average voxels 5 mm close to the 3d pial surface radius = 5. pial_mesh = fsaverage['pial_' + hemi] X = surface.vol_to_surf(fmri_img, pial_mesh, radius=radius).T # To define the BOLD responses to be included within each searchlight "sphere" # we define an adjacency matrix based on the inflated surface vertices such # that nearby surfaces are concatenated within the same searchlight. infl_mesh = fsaverage['infl_' + hemi] coords, _ = surface.load_surf_mesh(infl_mesh) radius = 3. nn = neighbors.NearestNeighbors(radius=radius) adjacency = nn.fit(coords).radius_neighbors_graph(coords).tolil() ######################################################################### # Searchlight computation # ----------------------- from sklearn.model_selection import KFold
localizer_dataset = datasets.fetch_localizer_button_task() localizer_tmap = localizer_dataset.tmaps[0] ############################################################################## # Get a cortical mesh # ------------------- fsaverage = datasets.fetch_surf_fsaverage5() ############################################################################## # Sample the 3D data around each node of the mesh # ----------------------------------------------- from nilearn import surface texture = surface.vol_to_surf(localizer_tmap, fsaverage.pial_right) ############################################################################## # Plot the result # --------------- from nilearn import plotting plotting.plot_surf_stat_map(fsaverage.infl_right, texture, hemi='right', title='Surface right hemisphere', threshold=1., bg_map=fsaverage.sulc_right) ############################################################################## # Plot 3D image for comparison # ----------------------------
%matplotlib qt nilearn.plotting.plot_stat_map(nilearn.image.smooth_img('/media/Data/work/KPE_SPM/Sink_ses-2/2ndLevel/_contrast_id_con_0001/spmT_0001.nii', 3), display_mode='x', threshold=5.5, bg_img=anatimg, dim=1)#%% Stat maps for con_image in conImages: nilearn.plotting.plot_stat_map(con_image, display_mode='ortho', threshold=2.3)#, cut_coords=(20,55)) #, 10, 15), dim=1) #%% Surface display import nibabel as nib from nilearn.plotting import plot_stat_map from nilearn import datasets, surface, plotting from nilearn import datasets fsaverage = datasets.fetch_surf_fsaverage() from nilearn import surface texture = surface.vol_to_surf('/media/Data/work/KPE_SPM/Sink_ses-2/2ndLevel/_contrast_id_con_0001/spmT_0001_thr.nii', fsaverage.pial_right) from nilearn import plotting a = '/media/Data/KPE_fmriPrep_preproc/kpeOutput/derivatives/fmriprep/sub-1263/ses-1/func/sub-1263_ses-1_task-Memory_space-fsaverage5_hemi-R.func.gii' plotting.plot_surf_stat_map(fsaverage.infl_right, texture, hemi='right', title='Surface right hemisphere', colorbar=True, threshold=0., bg_map=a)#fsaverage.sulc_right) big_fsaverage = datasets.fetch_surf_fsaverage('fsaverage') fmri_img = nib.load('/media/Data/work/KPE_SPM/Sink_ses-2/2ndLevel/_contrast_id_con_0001/spmT_0001_thr.nii') big_texture_right = surface.vol_to_surf(fmri_img, big_fsaverage.pial_right) %matplotlib inline plotting.plot_surf_stat_map(big_fsaverage.infl_right, big_texture_right, hemi='right', colorbar=True, title='', threshold=3,
motor_images = datasets.fetch_neurovault_motor_task() stat_img = motor_images.images[0] ############################################################################## # Get a cortical mesh # ------------------- fsaverage = datasets.fetch_surf_fsaverage() ############################################################################## # Sample the 3D data around each node of the mesh # ----------------------------------------------- from nilearn import surface texture = surface.vol_to_surf(stat_img, fsaverage.pial_right) ############################################################################## # Plot the result # --------------- # # You can visualize the texture on the surface using the function # :func:`~nilearn.plotting.plot_surf_stat_map` which uses ``matplotlib`` # as the default plotting engine: from nilearn import plotting fig = plotting.plot_surf_stat_map(fsaverage.infl_right, texture, hemi='right', title='Surface right hemisphere',
def plot_brainrsa_surface(img, threshold=None, type='r'): """ Plot the RSA-result into a brain surface Parameters ---------- img : string The file path of the .nii file of the RSA results. threshold : None or int. Default is None. The threshold of the number of voxels used in correction. If threshold=n, only the similarity clusters consisting more than threshold voxels will be visible. If it is None, the threshold-correction will not work. type : string 'r' or 't' The type of result (r-values or t-values). """ imgarray = nib.load(img).get_data() if (imgarray == np.nan).all() == True: print("No Valid Results") else: if threshold != None: imgarray = nib.load(img).get_data() affine = get_affine(img) imgarray = correct_by_threshold(imgarray, threshold) img = nib.Nifti1Image(imgarray, affine) fsaverage = datasets.fetch_surf_fsaverage(mesh='fsaverage') texture_left = surface.vol_to_surf(img, fsaverage.pial_left) texture_right = surface.vol_to_surf(img, fsaverage.pial_right) # type='r' if type == 'r': plotting.plot_surf_stat_map(fsaverage.pial_left, texture_left, hemi='left', threshold=0.1, bg_map=fsaverage.sulc_right, colorbar=False, vmax=0.8, darkness=0.7) plotting.plot_surf_stat_map(fsaverage.pial_right, texture_right, hemi='right', threshold=0.1, bg_map=fsaverage.sulc_right, colorbar=True, vmax=0.8, darkness=0.7) plotting.plot_surf_stat_map(fsaverage.pial_right, texture_left, hemi='left', threshold=0.1, bg_map=fsaverage.sulc_right, colorbar=False, vmax=0.8, darkness=0.7) plotting.plot_surf_stat_map(fsaverage.pial_left, texture_right, hemi='right', threshold=0.1, bg_map=fsaverage.sulc_right, colorbar=True, vmax=0.8, darkness=0.7) plt.show() # type='t' if type == 't': plotting.plot_surf_stat_map(fsaverage.pial_left, texture_left, hemi='left', threshold=0.8, bg_map=fsaverage.sulc_right, colorbar=False, darkness=0.7) plotting.plot_surf_stat_map(fsaverage.pial_right, texture_right, hemi='right', threshold=0.8, bg_map=fsaverage.sulc_right, colorbar=True, darkness=0.7) plotting.plot_surf_stat_map(fsaverage.pial_right, texture_left, hemi='left', threshold=0.8, bg_map=fsaverage.sulc_right, colorbar=False, darkness=0.7) plotting.plot_surf_stat_map(fsaverage.pial_left, texture_right, hemi='right', threshold=0.8, bg_map=fsaverage.sulc_right, colorbar=True, darkness=0.7) plt.show()
f'subj01_{model1}-{model2}_test_rho.nii.gz')) rho_map = masker.transform(file) rho_map_pos = [val if val > 0 else 0 for val in rho_map[0]] rho_map = masker.inverse_transform(rho_map) rho_map_pos = masker.inverse_transform(rho_map_pos) #%% # get surface mesh (fsaverage) fsaverage = datasets.fetch_surf_fsaverage() #%% # project volume onto surface # Caution: the projection is done for one hemisphere only, make sure to plot # (below) for the same hemisphere img_to_plot = surface.vol_to_surf(rho_map_pos, fsaverage.pial_right) #%% # plot surface # note: the bg_map and hemi should be the same hemisphere as fsaverage.??? plotting.plot_surf_stat_map(fsaverage.infl_right, img_to_plot, hemi='right', bg_map=fsaverage.sulc_right, view='lateral', title='Surface plot', colorbar=True, threshold=0.01) #%% # plot glass brain
for x in list(range(0, len(temp0state4))): LOstate4[LOstate4 == temp0state4.label[x]] = temp0state4.value[x] atlas_0state4 = nib.Nifti1Image(LOstate4, atlas_filename.affine, atlas_filename.header) LOstate5 = data.astype(float) temp0state5 = pd.DataFrame({'label': labellist, 'value': state5x_norm}) for x in list(range(0, len(temp0state5))): LOstate5[LOstate5 == temp0state5.label[x]] = temp0state5.value[x] atlas_0state5 = nib.Nifti1Image(LOstate5, atlas_filename.affine, atlas_filename.header) fsaverage = datasets.fetch_surf_fsaverage('fsaverage') ####### Plot state 1 texturestate1_l = surface.vol_to_surf(atlas_0state1, fsaverage.pial_left) texturestate1_r = surface.vol_to_surf(atlas_0state1, fsaverage.pial_right) fig, axs = plt.subplots(ncols=4, nrows=1, subplot_kw={'projection': '3d'}, figsize=(22, 5)) fig.tight_layout() plotting.plot_surf_stat_map(surf_mesh=fsaverage.infl_right, stat_map=texturestate1_r, bg_map=fsaverage.sulc_right, hemi='right', view='lateral', threshold=.084, colorbar=False, axes=axs[0])
fname = os.path.splitext(os.path.basename(n))[0] b_obj_proj_ll = BrainObj(template_brain, hemisphere='left', translucent=False) b_obj_proj_lr = BrainObj(template_brain, hemisphere='left', translucent=False) b_obj_proj_rr = BrainObj(template_brain, hemisphere='right', translucent=False) b_obj_proj_rl = BrainObj(template_brain, hemisphere='right', translucent=False) meshll = [b_obj_proj_ll.vertices, b_obj_proj_ll.faces] meshlr = [b_obj_proj_lr.vertices, b_obj_proj_lr.faces] meshrr = [b_obj_proj_rr.vertices, b_obj_proj_rr.faces] meshrl = [b_obj_proj_rl.vertices, b_obj_proj_rl.faces] texturell = surface.vol_to_surf(nii, meshll) texturelr = surface.vol_to_surf(nii, meshlr) texturerr = surface.vol_to_surf(nii, meshrr) texturerl = surface.vol_to_surf(nii, meshrl) texturell = texturell.ravel() texturelr = texturelr.ravel() texturerr = texturerr.ravel() texturerl = texturerl.ravel() b_obj_proj_ll.add_activation(texturell, hemisphere='left', cmap='hot_r', vmin=0, vmax=1, clim=(0, 1))