def view_connectome_with_nilearn(G, edge_attribute="weight", edge_cmap="Spectral_r", symmetric_cmap=True, edgewidth=6.0, node_size=3.0, node_colour_att=None, node_colour='black'): # node_colour_list=None): """ Plot a BrainNetwork using :func:`nilearn.plotting.view_connectome()` tool. Parameters ---------- G : :class:`networkx.Graph` G should have nodal locations in MNI space indexed by nodal attribute "centroids" node_colour_att : str, optional index a nodal attribute to scale node colour by edge_attribute : str, optional index an edge attribute to scale edge colour by other parameters are passed to :func:`nilearn.plotting.view_connectome()` """ adjacency_matrix, node_coords, colour_list, z = graph_to_nilearn_array( G, edge_attribute=edge_attribute, node_colour=node_colour_att) return plotting.view_connectome(adjacency_matrix, node_coords, threshold=None, cmap=edge_cmap, symmetric_cmap=symmetric_cmap, linewidth=edgewidth, marker_size=node_size)
def plot_connectome(mat, label_map, threshold='95%', GS=True): if GS: mat = mat[1:, 1:] #fisrt row and column is global signal coords = plotting.find_parcellation_cut_coords(label_map) view = plotting.view_connectome(mat, coords, threshold=threshold) view.open_in_browser()
def getConnectome(imgPath=None, atlasPath=None, viewInBrowser=False, displayCovMatrix=False): """ Gets the connectome of a functional MRI scan imgPath -> absolute or relative path to the .nii file atlasPath -> download path for the reference MSDL atlas viewInBrowser (optional, default=False) -> if True, opens up an interactive viewer in the browser displayCovMatrix (optional, default=False) -> display the inverse covariance matrix Returns a tuple of shape (estimator, atlas) """ # Download the reference atlas atlas = datasets.fetch_atlas_msdl(data_dir=atlasPath) # Loading atlas image stored in 'maps' atlasFilename = atlas['maps'] # Get the time series for the fMRI scan masker = NiftiMapsMasker(maps_img=atlasFilename, standardize=True, memory='nilearn_cache', verbose=5) timeSeries = masker.fit_transform(imgPath) # Compute the connectome using sparse inverse covariance estimator = GraphicalLassoCV() estimator.fit(timeSeries) if (displayCovMatrix): labels = atlas['labels'] plotting.plot_matrix(estimator.covariance_, labels=labels, figure=(9, 7), vmax=1, vmin=-1, title='Covariance') plotting.plot_matrix(estimator.precision_, labels=labels, figure=(9, 7), vmax=1, vmin=-1, title='Inverse covariance (Precision)') #covPlot.get_figure().savefig('Covariance.png') # precPlot.get_figure().savefig('Inverse Covariance.png') if (viewInBrowser): coords = atlas.region_coords view = plotting.view_connectome(-estimator.precision_, coords, '60.0%') #view.save_as_html(file_name='Connectome Test.html') view.open_in_browser() return (estimator, atlas)
def plot_connectivity_matrix(matrix_data,matrix_name:str): ''' The connectivity_matrix nilearn implementation allows the visualization of the matrices based on the atlas and matrix selected. ''' # Plot the tangent matrix # The labels of the MSDL Atlas that we are using # Data from the atlas used (in the given example MSDL) atlas = datasets.fetch_atlas_msdl() # Loading atlas data stored in 'labels' labels = atlas['labels'] # Loading atlas coordinates coords = atlas.region_coords font = {'family': 'serif', 'color': 'black', 'weight': 'bold', 'size': 12} tt = plt.figure(1,figsize=(7,6)) np.fill_diagonal(matrix_data, 0) plt.imshow(matrix_data, interpolation='None', cmap='RdYlBu_r', vmax=.000002, vmin=-.000002) plt.yticks(range(len(atlas.labels)),labels, fontsize=10, weight='bold'); plt.xticks( range(len(atlas.labels)), labels, rotation=90, fontsize=10, weight='bold'); plt.title(str(matrix_name)+'_msdl',fontdict=font) plt.colorbar(shrink=0.8) tt2 = plt.figure(2) view=plotting.view_connectome(matrix_data,coords, node_size=5.0, edge_threshold='99.5%') plt.show() return view
"""weights: 168 recordings, 39 roi, but it transposed Brain Synchrony: Connectome """ from nilearn.connectome import ConnectivityMeasure correlation_measure = ConnectivityMeasure(kind='correlation') correlation_matrix = correlation_measure.fit_transform([roi_time_series])[0] np.fill_diagonal(correlation_matrix, 0) plotting.plot_matrix(correlation_matrix, labels=msdl_atlas.labels, vmax=0.8, vmin=-0.8, colorbar=True) plotting.view_connectome(correlation_matrix, edge_threshold=0.2, node_coords=msdl_atlas.region_coords) """###Noise sources""" pd.read_table(development_dataset.confounds[0]).head() corrected_roi_time_series = masker.transform( development_dataset.func[0], confounds=development_dataset.confounds[0]) corrected_correlation_matrix = correlation_measure.fit_transform( [corrected_roi_time_series])[0] np.fill_diagonal(corrected_correlation_matrix, 0) plotting.plot_matrix(corrected_correlation_matrix, labels=msdl_atlas.labels, vmax=0.8, vmin=-0.8, colorbar=True) plotting.view_connectome(corrected_correlation_matrix, edge_threshold=0.2, node_coords=msdl_atlas.region_coords)
def view_connectome_3d(G, edge_threshold="98%", edge_cmap="Spectral_r", symmetric_cmap=False, linewidth=6., node_size=3.): """ Insert a 3d plot of a connectome into an HTML page. Plot a BrainNetwork using :func:`nilearn.plotting.view_connectome()` tool. Parameters ---------- G : :class:`networkx.Graph` G should have nodal locations in MNI space indexed by nodal attribute "centroids". edge_threshold : str, number or None, optional (default="2%") If None, no thresholding. If it is a number only connections of amplitude greater than threshold will be shown. If it is a string it must finish with a percent sign, e.g. "25.3%", and only connections of amplitude above the given percentile will be shown. edge_cmap : str or matplotlib colormap, optional Colormap for displaying edges. symmetric_cmap : bool, optional (default=False) Make colormap symmetric (ranging from -vmax to vmax). linewidth : float, optional (default=6.) Width of the lines that show connections. node_size : float, optional (default=3.) Size of the markers showing the seeds in pixels. Returns ------- ConnectomeView : plot of the connectome. It can be saved as an html page or rendered (transparently) by the Jupyter notebook. Useful methods are : - 'resize' to resize the plot displayed in a Jupyter notebook - 'save_as_html' to save the plot to a file - 'open_in_browser' to save the plot and open it in a web browser. """ # get the adjacency matrix and nodes coordinates adj_matrix, node_coords = graph_to_nilearn_array(G) # plot connectome ConnectomeView = plotting.view_connectome(adjacency_matrix=adj_matrix, node_coords=node_coords, edge_threshold=edge_threshold, edge_cmap=edge_cmap, symmetric_cmap=symmetric_cmap, linewidth=linewidth, node_size=node_size) return ConnectomeView
plt.figure(figsize=(10, 10)) # Mask out the major diagonal numpy.fill_diagonal(correlation_matrix, 0) plt.imshow(correlation_matrix, interpolation="nearest", cmap="RdBu_r", vmax=0.8, vmin=-0.8) plt.colorbar() # And display the labels x_ticks = plt.xticks(range(len(labels)), labels, rotation=90) y_ticks = plt.yticks(range(len(labels)), labels) #coords = atlas.region_coords # We threshold to keep only the 20% of edges with the highest value # because the graph is very dense plotting.plot_connectome(correlation_matrix, atlas_coords_, edge_threshold="80%", colorbar=True) plotting.show() view = plotting.view_connectome(correlation_matrix, atlas_coords_, edge_threshold="80%") view.save_as_html('t.html') view.open_in_browser()
node = np.unique(node) # 显示连接网络 weight_filter = weight[id_mat[0], id_mat[1]] wei_node = np.hstack([node1, node2]).T wei_node = np.vstack([wei_node, np.hstack([weight_filter, weight_filter])]).T nodes = [{"name": nd, "symbolSize": np.sum(np.abs(np.float64(wei_node[:,1][np.in1d(wei_node[:,0], str(nd))])))*10} for nd in node] links = [{"source": str(nd1), "target": str(nd2)} for (nd1, nd2) in zip(node1, node2)] graph= ( Graph() .add("", nodes,links, repulsion=1000) .set_global_opts(title_opts=opts.TitleOpts(title="前0.1%的权重")) ) graph.render() # 只显示靠前的权重 plt.imshow(weight, cmap="RdBu_r") plt.colorbar() plotting.plot_connectome(weight, node_coords, annotate=True) view = plotting.view_connectome(weight, node_coords) view.open_in_browser() from chord import Chord names = [str(i) for i in range(246)] chrod_fig = Chord(weight, names, colors="d3.schemeSet2").to_html("chrod_fig.html")
############################################################################## # 3D visualization in a web browser # --------------------------------- # An alternative to :func:`nilearn.plotting.plot_surf_roi` is to use # :func:`nilearn.plotting.view_surf` for more interactive # visualizations in a web browser. See :ref:`interactive-surface-plotting` for # more details. view = plotting.view_surf(fsaverage.infl_left, parcellation, cmap='gist_ncar', symmetric_cmap=False) # In a Jupyter notebook, if ``view`` is the output of a cell, it will # be displayed below the cell view ############################################################################## # uncomment this to open the plot in a web browser: # view.open_in_browser() ############################################################################## # you can also use :func:`nilearn.plotting.view_connectome` to open an # interactive view of the connectome. view = plotting.view_connectome(corr, coordinates, edge_threshold='90%') # uncomment this to open the plot in a web browser: # view.open_in_browser() view
def plotConnectome(matrix, coords, networks, out_folder, base_name, min_r): """Creates brain plot with connections according to minimum R value param matrix: two dimensional array. The correlation matrix param coords : list. Coordinates of the networks param networks: list. Networks names. param out_folder: string. Output folder for brain plot param base_name: string. Base name param min_r: float. The minimun R value for connection plotting. return: None """ colors = [] patches_list = [] index2network = {} last_index = 0 for network in networks: network_color = [net_dic.labelToColorDic[network]] * len( list(net_dic.dic[network])) colors = colors + network_color for i in range(last_index, last_index + len(list(net_dic.dic[network]))): index2network[i] = network last_index = i + 1 network_patch = mpatches.Patch(color=net_dic.labelToColorDic[network], label=network) patches_list.append(network_patch) correlated_coords = {} for i in range(1, len(matrix)): for j in range(i): if (matrix[i][j] >= min_r): correlated_coords[matrix[i][j]] = ({ index2network[i]: coords[i] }, { index2network[j]: coords[j] }) plot_name = out_folder + "/" + base_name + "_brain_plot" + str( networks) + ".png" if (len(correlated_coords) > 0): fig = plt.figure() title = "Threshold : " + str(min_r) plotting.plot_connectome(adjacency_matrix=matrix, node_coords=coords, title=title, node_color=colors, colorbar=True, edge_threshold=min_r, node_size=5, edge_vmin=-1, edge_vmax=1, figure=fig, display_mode='lyrz') fig.legend(handles=patches_list, loc="upper center") fig.savefig(plot_name) plt.close() view = plotting.view_connectome(matrix, coords, edge_threshold=min_r, node_size=7, symmetric_cmap=True) html_name = out_folder + "/" + base_name + "_brain_plot" + str( networks) + ".html" view.save_as_html(html_name)
significantconnectDiff = np.multiply(significantconnectDiff, pvaluesDiff) plot_matrix(significantconnectDiff, labels=labels, colorbar=True, tri='full', reorder=False) significantconnectOdorVsOff = 1 * (pvaluesOdorVsOff <= 0.05) plot_matrix(significantconnectOdorVsOff, title='Significant Connect', labels=labels, colorbar=True, tri='full', reorder=False) #---- Show plotted matrixes ------ show() #------------------------------------------------------------------------------ # Read channel locations #------------------------------------------------------------------------------ # coords = read_channLoc(channelLocationsPath) coords = read_channLocMNI(channelLocationsPath) #------------------------------------------------------------------------------ # Show visualization in browser #------------------------------------------------------------------------------ view = view_connectome(significantconnectDiff, coords, edge_threshold='95%') #view = view_connectome(significantconnectOdorVsOff, coords, edge_threshold='90%') view.open_in_browser() x = input("Done...press to exit")
] masked_data = np.asarray(masked_data) print('masked data shape:', masked_data[0].shape) ############################################################################### # Compute and plot connectivity matrix from nilearn.connectome import ConnectivityMeasure correlation_measure = ConnectivityMeasure(kind='correlation').fit(masked_data) plotting.plot_matrix(correlation_measure.mean_, tri='lower') ############################################################################### plotting.view_connectome(correlation_measure.mean_, msdl.region_coords, threshold='90%', cmap='cold_hot') ############################################################################### # Age group classification with scikit-learn # ------------------------------------------ # `ConnectivityMeasure` can be used to extract features for supervised learning from sklearn.svm import LinearSVC from sklearn.model_selection import StratifiedShuffleSplit from sklearn.preprocessing import LabelEncoder from sklearn.model_selection import cross_val_score kinds = ['correlation', 'partial correlation', 'tangent'] groups = [pheno['Child_Adult'] for pheno in rest_data.phenotypic] classes = LabelEncoder().fit_transform(groups)
figure=(9, 7), vmax=1, vmin=-1, title='Sparse inverse covariance') ############################################################################## # And now display the corresponding graph # ---------------------------------------- plotting.plot_connectome(-estimator.precision_, coords, title='Sparse inverse covariance') plotting.show() ############################################################################## # 3D visualization in a web browser # --------------------------------- # An alternative to :func:`nilearn.plotting.plot_connectome` is to use # :func:`nilearn.plotting.view_connectome` that gives more interactive # visualizations in a web browser. See :ref:`interactive-connectome-plotting` # for more details. view = plotting.view_connectome(-estimator.precision_, coords) # uncomment this to open the plot in a web browser: # view.open_in_browser() ############################################################################## # In a Jupyter notebook, if ``view`` is the output of a cell, it will # be displayed below the cell view
os.makedirs(common_mat_folder) #Plot the common matrices fig = plt.figure() plotting.plot_matrix(common_cov_mat, colorbar=True, labels=labels, figure=fig, title='Common covariance matrix') fig.savefig(common_mat_folder + "/common_cov_matrix_" + str(argList) + ".png") fig2 = plt.figure() plotting.plot_matrix(common_cor_mat, colorbar=True, labels=labels, vmin=-1., vmax=1., figure=fig2, title='Common correlation matrix') fig2.savefig(common_mat_folder + "/common_cor_matrix_" + str(argList) + ".png") fig3 = plt.figure() plotting.plot_connectome(adjacency_matrix=common_cor_mat, node_coords=coords, edge_threshold="80%", colorbar=True, edge_vmin=-1, edge_vmax=1, figure=fig3, title=str(argList)) fig3.savefig(common_mat_folder + "/brain_plot_" + str(argList) + ".png") view = plotting.view_connectome(common_cor_mat, coords, threshold="80%") view.open_in_browser()
title="Connectivity projected on hemispheres", display_mode='lyrz') plotting.show() ############################################################################## # 3D visualization in a web browser # --------------------------------- # An alternative to :func:`nilearn.plotting.plot_connectome` is to use # :func:`nilearn.plotting.view_connectome`, which gives more interactive # visualizations in a web browser. See :ref:`interactive-connectome-plotting` # for more details. view = plotting.view_connectome(partial_correlation_matrix, dmn_coords) # uncomment this to open the plot in a web browser: # view.open_in_browser() ############################################################################## # In a Jupyter notebook, if ``view`` is the output of a cell, it will # be displayed below the cell view ########################################################################## # Extract signals on spheres from an atlas # ----------------------------------------
vmin=-1, title='Sparse inverse covariance') ############################################################################## # And now display the corresponding graph # ---------------------------------------- plotting.plot_connectome(-estimator.precision_, coords, title='Sparse inverse covariance') plotting.show() ############################################################################## # 3D visualization in a web browser # --------------------------------- # An alternative to :func:`nilearn.plotting.plot_connectome` is to use # :func:`nilearn.plotting.view_connectome` that gives more interactive # visualizations in a web browser. See :ref:`interactive-connectome-plotting` # for more details. view = plotting.view_connectome(-estimator.precision_, coords) # uncomment this to open the plot in a web browser: # view.open_in_browser() ############################################################################## # In a Jupyter notebook, if ``view`` is the output of a cell, it will # be displayed below the cell view
def plot_all(matrix, title, time_series, coords_file, labels_file, output_dir, clean=True, vmin=None, vmax=None, nan_matrix=False, pconn_dummy=False, pconn_fname='correlation_measure-mean_.pconn.nii'): # Before anything else, save matrix (i.e. corelation_measure.mean) as binary npy # file (e.g. to manually create pconn CIFTIs) create_dir_if_not_exist(output_dir) matrix_fname = os.path.join(output_dir, 'correlation_measure-mean_.npy') np.save(matrix_fname, matrix) # Build pconn file if pconn_dummy: pconn_fname = os.path.join(output_dir, pconn_fname) print("Saving pconn file to {}...".format(pconn_fname)) save_pconn(matrix, pconn_dummy, pconn_fname) plot_title = title + ", n = {}".format(len(time_series)) plot_title_orig = plot_title # We might modify plot_title later on coordinates = np.loadtxt(coords_file) labels = load_list_from_file(labels_file) if not os.path.exists(output_dir): os.makedirs(output_dir) if nan_matrix is False: nan_matrix = matrix timer("tic") np.fill_diagonal(matrix, 0) # plotting.plot_matrix(nan_matrix, colorbar=True, figure=(40, 40), labels=labels, auto_fit=True, vmin=vmin, vmax=vmax) # plt.title(plot_title, fontsize=50) # fig_fname = "{}/correlation_matrix.svg".format(output_dir) # plt.savefig(fig_fname) # plt.clf() # We need to introduce this as clean_matrix does something unexpected with np.nan values # and plot_connectome specifically cannot deal with this if clean: print("Cleaning matrix ...") mean_roi_matrix = clean_matrix(matrix) plot_title = plot_title + " (clean)" fname_clean = "clean" else: mean_roi_matrix = matrix fname_clean = "nonclean" fig_fname = os.path.join(output_dir, "correlation_matrix_{}".format(fname_clean)) print("Plotting matrix...") plotting.plot_matrix(mean_roi_matrix, colorbar=True, figure=(40, 40), labels=labels, auto_fit=True, vmin=vmin, vmax=vmax) plt.title(plot_title, fontsize=50) print("Saving plot to {}.svg...".format(fig_fname)) plt.savefig("{}.svg".format(fig_fname)) #plt.savefig("{}.png".format(fig_fname), dpi=1080) # PNG export does not seem to work in this case. Who knows.. timer("toc", name="plotting and saving matrices") plt.clf() print("Plotting connectome ...") timer("tic") # Manually create new figure because for some reason plotting.plot_connectome() won't # accept figure size like plotting.plot_matrix() connectome_figure = plt.figure(figsize=(10, 5)) # plot_connectome does not process np.nan values, we still have to pass np.nan_to_num(matrix) to plot_all function plotting.plot_connectome(np.nan_to_num(mean_roi_matrix), coordinates, figure=connectome_figure, colorbar=True, node_size=30, title=plot_title, edge_vmin=vmin, edge_vmax=vmax) fig_fname = os.path.join(output_dir, "roi_connectome_{}".format(fname_clean)) plt.savefig("{}.svg".format(fig_fname)) plt.savefig("{}.png".format(fig_fname), dpi=1080) timer("toc", name="plotting and saving connectome") plt.clf() html_fname = os.path.join(output_dir, "roi_connectome_90_{}.html".format(fname_clean)) print("Constructing interactive HTML connectome...") timer("tic") web_connectome = plotting.view_connectome(mean_roi_matrix, coordinates, edge_threshold="99%", node_size=6, symmetric_cmap=False) html_fname = os.path.join(output_dir, "roi_connectome_{}.html".format(fname_clean)) web_connectome.save_as_html(html_fname) timer("toc", name="plotting and saving HTML connectome")
# ---------------------------------------- from nilearn import plotting coords = atlas.region_coords # We threshold to keep only the 20% of edges with the highest value # because the graph is very dense plotting.plot_connectome(correlation_matrix, coords, edge_threshold="80%", colorbar=True) plotting.show() ############################################################################## # 3D visualization in a web browser # --------------------------------- # An alternative to :func:`nilearn.plotting.plot_connectome` is to use # :func:`nilearn.plotting.view_connectome` that gives more interactive # visualizations in a web browser. See :ref:`interactive-connectome-plotting` # for more details. view = plotting.view_connectome(correlation_matrix, coords, threshold='80%') # uncomment this to open the plot in a web browser: # view.open_in_browser() ############################################################################## # In a Jupyter notebook, if ``view`` is the output of a cell, it will # be displayed below the cell view
def plot_palm_new(palm_results, title, coords, labels, alpha=1.3, scale=False, n_best_values=5, lower_is_better=False, output_dir=None, pconn_dummy=False, pconn_fname='connectome.pconn.nii'): """ Take PALM results (file or NumPy array) and plot its suprathreshold values (default threshold value: alpha=1.3) in a correlation matrix and as a connectome visualisation. Use lower_is_better=True if you use standard p values and not log p or 1-p """ if isinstance(palm_results, str): # We assume the argument is a filename if it's a string data = get_nimg_data(palm_results) info = [ "PALM results: {}".format(palm_results) ] # This list holds all the informational messages we may later write into info.txt else: data = palm_results info = [ "PALM results:" ] # This list holds all the informational messages we may later write into info.txt # Get rid of superfluous dimensions adjmatrix = data[:, :, 0, 0] # Plot all p values fig_matrix = plotting.plot_matrix(adjmatrix, colorbar=True, figure=(40, 40), labels=labels, auto_fit=True).figure fig_connectome = plotting.plot_connectome(symmetrize(adjmatrix, mirror_lower=True), coords, colorbar=True, node_size=15, title=title) web_connectome = plotting.view_connectome(adjmatrix, coords, node_size=6, symmetric_cmap=False) # Get highest/lowest indices and check if there are any suprathreshold values if lower_is_better: best_indices = get_extreme_indices(abs(adjmatrix), n_best_values, get_smallest=True) adjmatrix[adjmatrix == 0] = np.nan # See get_extreme_indices() for rationale nsupthr = len(adjmatrix[abs(adjmatrix) <= alpha]) else: best_indices = get_extreme_indices(abs(adjmatrix), n_best_values) nsupthr = len(adjmatrix[abs(adjmatrix) >= alpha]) msg = "{} best values: {}".format(n_best_values, adjmatrix[best_indices]) info.append(msg) print(msg) if nsupthr == 0: msg = "\nNo values survive the threshold of {}.".format(alpha) info.append(msg) print(msg) fig_matrix_clean, fig_connectome_clean, web_connectome_clean = None, None, None labels_clean = "" coords_clean = "" else: msg = "Number of values to survive the threshold of {}: {}".format( alpha, nsupthr) info.append(msg) print(msg) # Purge matrix, coordinates and labels of subthreshold values adjmatrix_clean = adjmatrix.copy() if lower_is_better: adjmatrix_clean[abs(adjmatrix) > alpha] = np.nan else: adjmatrix_clean[abs(adjmatrix_clean) < alpha] = np.nan supthr_indices = np.argwhere(~np.isnan(adjmatrix_clean)) labels_clean = [ "" if i not in supthr_indices else x for i, x in enumerate(labels) ] coords_clean = [ [np.nan, np.nan, np.nan] if i not in supthr_indices else x for i, x in enumerate(coords) ] fig_matrix_clean = plotting.plot_matrix(adjmatrix_clean, colorbar=True, figure=(40, 40), labels=labels_clean, auto_fit=True).figure fig_connectome_clean = plotting.plot_connectome( symmetrize(np.nan_to_num(adjmatrix_clean), mirror_lower=True), coords_clean, figure=plt.figure(figsize=(10, 5)), colorbar=True, node_size=30, title=title) web_connectome_clean = plotting.view_connectome(adjmatrix_clean, coords_clean, node_size=6, symmetric_cmap=False) if output_dir: create_dir_if_not_exist(output_dir) print("Saving plots to {}...".format(output_dir)) fig_matrix.savefig(os.path.join(output_dir, "matrix.svg")) if fig_matrix_clean: fig_matrix_clean.savefig( os.path.join(output_dir, "matrix_clean.svg")) fig_connectome.savefig(os.path.join(output_dir, "connectome.svg")) if fig_connectome_clean: fig_connectome_clean.savefig( os.path.join(output_dir, "connectome_clean.svg")) web_connectome.save_as_html( os.path.join(output_dir, "web_connectome.html")) if web_connectome_clean: web_connectome_clean.save_as_html( os.path.join(output_dir, "web_connectome_clean.html")) info.append("") info.append("Top 5 connections according to p value:") info.append("Node A (label) <-> Node B (label): p value") for i in range(5): x = best_indices[0][i] y = best_indices[1][i] msg = "{} ({}) <-> {} ({}): {}".format(x + 1, labels[x], y + 1, labels[y], adjmatrix[x, y]) info.append(msg) save_list_to_file(info, os.path.join(output_dir, "info.txt")) if labels_clean: save_list_to_file(labels_clean, os.path.join(output_dir, "labels_clean")) np.savetxt(os.path.join(output_dir, "coords_clean"), coords_clean) if pconn_dummy: save_pconn(adjmatrix, pconn_dummy, os.path.join(output_dir, pconn_fname)) for entry in info: print(entry) return fig_matrix, fig_matrix_clean, fig_connectome, fig_connectome_clean, web_connectome, web_connectome_clean, labels_clean, coords_clean
title="Default Mode Network Connectivity") ########################################################################## # Display connectome with hemispheric projections. # Notice (0, -52, 18) is included in both hemispheres since x == 0. plotting.plot_connectome(partial_correlation_matrix, dmn_coords, title="Connectivity projected on hemispheres", display_mode='lyrz') plotting.show() ############################################################################## # 3D visualization in a web browser # --------------------------------- # An alternative to :func:`nilearn.plotting.plot_connectome` is to use # :func:`nilearn.plotting.view_connectome` that gives more interactive # visualizations in a web browser. See :ref:`interactive-connectome-plotting` # for more details. view = plotting.view_connectome(partial_correlation_matrix, dmn_coords) # uncomment this to open the plot in a web browser: # view.open_in_browser() ############################################################################## # In a Jupyter notebook, if ``view`` is the output of a cell, it will # be displayed below the cell view
title='fsaverage Destrieux atlas') plotting.show() ############################################################################## # 3D visualization in a web browser # --------------------------------- # An alternative to :func:`nilearn.plotting.plot_surf_roi` is to use # :func:`nilearn.plotting.view_surf` for more interactive # visualizations in a web browser. See :ref:`interactive-surface-plotting` for # more details. view = plotting.view_surf(fsaverage.infl_left, parcellation, cmap='gist_ncar', symmetric_cmap=False) # uncomment this to open the plot in a web browser: # view.open_in_browser() ############################################################################## # In a Jupyter notebook, if ``view`` is the output of a cell, it will # be displayed below the cell view ############################################################################## # you can also use :func:`nilearn.plotting.view_connectome` to open an # interactive view of the connectome. view = plotting.view_connectome(corr, coordinates, edge_threshold='90%') # uncomment this to open the plot in a web browser: # view.open_in_browser() view
from nilearn import plotting coords = atlas.region_coords # We threshold to keep only the 20% of edges with the highest value # because the graph is very dense plotting.plot_connectome(correlation_matrix, coords, edge_threshold="80%", colorbar=True) plotting.show() ############################################################################## # 3D visualization in a web browser # --------------------------------- # An alternative to :func:`nilearn.plotting.plot_connectome` is to use # :func:`nilearn.plotting.view_connectome` that gives more interactive # visualizations in a web browser. See :ref:`interactive-connectome-plotting` # for more details. view = plotting.view_connectome(correlation_matrix, coords, threshold='80%') # uncomment this to open the plot in a web browser: # view.open_in_browser() ############################################################################## # In a Jupyter notebook, if ``view`` is the output of a cell, it will # be displayed below the cell view
#%% plotting stuff # take colors colors = pd.read_csv('/home/or/Downloads/shenPar/shen_268_parcellation_networklabels_colors.csv') color_node = list(colors["color"]) # plot in specific region as seed # create 268 x 268 array empty = np.zeros((268,268)) # take only left amygdala connections empty[227,:] = trauma_1st_thr[227,:] empty[:,227] = trauma_1st_thr[:,227] # plot plotting.plot_connectome(empty, coords, edge_threshold='95%', colorbar=True, black_bg = False, annotate = True, node_color = color_node) # plot in browser view = plotting.view_connectome(empty, coords, threshold='90%') view.open_in_browser() view_color.open_in_browser() #%% Run Network Based Analysis # first reshape the matrix dimensions (right now its [subs,x,y]) to [x,y,subs] trt1Reshape = np.moveaxis(np.array(trauma_1st_ses),0,-1) trt2Reshape = np.moveaxis(np.array(trauma_2_1st_ses),0,-1) from bct import nbs # we compare ket1 and ket3 pval, adj, _ = nbs.nbs_bct(trt1Reshape, trt2Reshape, thresh=2.5, tail='both',k=500, paired=True, verbose = True) # one network is different #%% compare sad to trauma 1