def plot_connectivity(con, n_lines=None, node_angles=None, node_width=None, node_colors=None, facecolor='black', textcolor='white', node_edgecolor='black', linewidth=1.5, colormap='hot', vmin=None, vmax=None, colorbar=True, title=None, colorbar_size=0.2, colorbar_pos=(-0.3, 0.1), fontsize_title=12, fontsize_names=8, fontsize_colorbar=8, padding=6., fig=None, subplot=111, interactive=True, node_linewidth=2., show=True): """Visualize parcellated connectivity as a circular graph. Parameters ---------- con : instance of LabelConnectivity The parcellated connectivity to visualize. n_lines : int | None If not None, only the n_lines strongest connections (strength=abs(con)) are drawn. node_angles : array, shape=(len(node_names,)) | None Array with node positions in degrees. If None, the nodes are equally spaced on the circle. See :func:`mne.viz.circular_layout`. node_width : float | None Width of each node in degrees. If None, the minimum angle between any two nodes is used as the width. node_colors : list of tuples | list of str List with the color to use for each node. If fewer colors than nodes are provided, the colors will be repeated. Any color supported by matplotlib can be used, e.g., RGBA tuples, named colors. facecolor : str Color to use for background. See matplotlib.colors. textcolor : str Color to use for text. See matplotlib.colors. node_edgecolor : str Color to use for lines around nodes. See matplotlib.colors. linewidth : float Line width to use for connections. colormap : str Colormap to use for coloring the connections. vmin : float | None Minimum value for colormap. If None, it is determined automatically. vmax : float | None Maximum value for colormap. If None, it is determined automatically. colorbar : bool Display a colorbar or not. title : str The figure title. colorbar_size : float Size of the colorbar. colorbar_pos : 2-tuple Position of the colorbar. fontsize_title : int Font size to use for title. fontsize_names : int Font size to use for node names. fontsize_colorbar : int Font size to use for colorbar. padding : float Space to add around figure to accommodate long labels. fig : None | instance of matplotlib.pyplot.Figure The figure to use. If None, a new figure with the specified background color will be created. subplot : int | 3-tuple Location of the subplot when creating figures with multiple plots. E.g. 121 or (1, 2, 1) for 1 row, 2 columns, plot 1. See matplotlib.pyplot.subplot. interactive : bool When enabled, left-click on a node to show only connections to that node. Right-click shows all connections. node_linewidth : float Line with for nodes. show : bool Show figure if True. Returns ------- fig : instance of matplotlib.pyplot.Figure The figure handle. axes : instance of matplotlib.axes.PolarAxesSubplot The subplot handle. """ names = [l.name for l in con.labels] if node_colors is None: node_colors = [l.color for l in con.labels] if node_angles is None: # Try to construct a sensible default layout # First, we reorder the labels based on their location in the left # hemisphere. lh_labels = [name for name in names if name.endswith('lh')] # Get the y-location of the label label_ypos = list() for name in lh_labels: idx = names.index(name) ypos = np.mean(con.labels[idx].pos[:, 1]) label_ypos.append(ypos) # Reorder the labels based on their location lh_labels = [ label for (yp, label) in sorted(zip(label_ypos, lh_labels)) ] # Second, we reorder the labels based on their location in the right # hemisphere. rh_labels = [name for name in names if name.endswith('rh')] # For the right hemi # Get the y-location of the label rlabel_ypos = list() for name in rh_labels: idx = names.index(name) ypos = np.mean(con.labels[idx].pos[:, 1]) rlabel_ypos.append(ypos) # Reorder the labels based on their location rh_labels = [ label for (yp, label) in sorted(zip(rlabel_ypos, rh_labels), reverse=True) ] # Save the plot order and create a circular layout node_order = list() node_order.extend(lh_labels[::-1]) # reverse the order node_order.extend(rh_labels[::-1]) # reverse the order node_angles = circular_layout(names, node_order, start_pos=90, group_boundaries=[0, len(names) / 2]) return plot_connectivity_circle(con.data, node_names=names, indices=con.pairs, n_lines=n_lines, node_angles=node_angles, node_width=node_width, node_colors=node_colors, facecolor=facecolor, textcolor=textcolor, node_edgecolor=node_edgecolor, linewidth=linewidth, colormap=colormap, vmin=vmin, vmax=vmax, colorbar=colorbar, title=title, colorbar_size=colorbar_size, colorbar_pos=colorbar_pos, fontsize_title=fontsize_title, fontsize_names=fontsize_names, fontsize_colorbar=fontsize_colorbar, padding=padding, fig=fig, interactive=interactive, node_linewidth=node_linewidth, show=show)
def plot_grouped_connectivity_circle(yaml_fname, con, orig_labels, node_order_size=68, out_fname='circle.png', title=None, subplot=111, include_legend=False, n_lines=None, fig=None, show=True, vmin=None, vmax=None, colorbar=False): ''' Plot the connectivity circle grouped and ordered according to groups in the yaml input file provided. orig_labels : list of str Label names in the order as appears in con. ''' # read the yaml file with grouping if op.isfile(yaml_fname): with open(yaml_fname, 'r') as f: labels = yaml.load(f) else: print '%s - File not found.' % yaml_fname sys.exit() cortex_colors = ['m', 'b', 'y', 'c', 'r', 'g', 'g', 'r', 'c', 'y', 'b', 'm'] # make list of label_names (without individual cortex locations) label_names = list() for lab in labels: label_names.extend(labels[lab]) lh_labels = [name + '-lh' for name in label_names] rh_labels = [name + '-rh' for name in label_names] # Save the plot order and create a circular layout node_order = list() node_order.extend(lh_labels[::-1]) # reverse the order node_order.extend(rh_labels) assert len(node_order) == node_order_size, 'Node order length is correct.' # the respective no. of regions in each cortex group_bound = [len(labels[key]) for key in labels.keys()] group_bound = [0] + group_bound[::-1] + group_bound group_boundaries = [sum(group_bound[:i+1]) for i in range(len(group_bound))] # remove the first element of group_bound # make label colours such that each cortex is of one colour group_bound.pop(0) label_colors = [] for ind, rep in enumerate(group_bound): label_colors += [cortex_colors[ind]] * rep assert len(label_colors) == len(node_order), 'Number of colours do not match' # remove the last total sum of the list group_boundaries.pop() from mne.viz.circle import circular_layout node_angles = circular_layout(orig_labels, node_order, start_pos=90, group_boundaries=group_boundaries) # the order of the node_colors must match that of orig_labels # therefore below reordering is necessary reordered_colors = [label_colors[node_order.index(orig)] for orig in orig_labels] # Plot the graph using node_order and colours # orig_labels is the order on nodes in the con matrix (important) from mne.viz import plot_connectivity_circle plot_connectivity_circle(con, orig_labels, n_lines=n_lines, facecolor='white', textcolor='black', node_angles=node_angles, node_colors=reordered_colors, node_edgecolor='white', fig=fig, fontsize_names=6, vmax=vmax, vmin=vmin, colorbar_size=0.2, colorbar_pos=(-0.3, 0.1), colorbar=colorbar, show=show, subplot=subplot, title=title) if include_legend: import matplotlib.patches as mpatches legend_patches = [mpatches.Patch(color=col, label=key) for col, key in zip(['g', 'r', 'c', 'y', 'b', 'm'], labels.keys())] pl.legend(handles=legend_patches, loc=(0.02, 0.02), ncol=1, mode=None, fontsize='small') if out_fname: pl.savefig(out_fname, facecolor='white', dpi=300)
def plot_grouped_connectivity_circle(yaml_fname, con, orig_labels, labels_mode=None, node_order_size=68, indices=None, out_fname='circle.png', title=None, subplot=111, include_legend=False, n_lines=None, fig=None, show=True, vmin=None, vmax=None, colormap='hot', colorbar=False, colorbar_pos=(-0.3, 0.1), bbox_inches=None, tight_layout=None, **kwargs): ''' Plot the connectivity circle grouped and ordered according to groups in the yaml input file provided. orig_labels : list of str Label names in the order as appears in con. labels_mode : str | None 'blank' mode plots no labels on the circle plot, 'cortex_only' plots only the name of the cortex on one representative node and None plots all of the orig_label names provided. bbox_inches : None | 'tight' tight_layout : bool NOTE: yaml order fix helps preserves the order of entries in the yaml file. ''' import matplotlib.pyplot as plt # read the yaml file with grouping if op.isfile(yaml_fname): with open(yaml_fname, 'r') as f: labels = yaml.load(f) else: print '%s - File not found.' % yaml_fname sys.exit() cortex_colors = [ 'm', 'b', 'y', 'c', 'r', 'g', 'g', 'r', 'c', 'y', 'b', 'm' ] # make list of label_names (without individual cortex locations) label_names = list() for lab in labels: # label_names.extend(labels[lab]) label_names += lab.values()[0] # yaml order fix lh_labels = [name + '-lh' for name in label_names] rh_labels = [name + '-rh' for name in label_names] # Save the plot order and create a circular layout node_order = list() node_order.extend(lh_labels[::-1]) # reverse the order node_order.extend(rh_labels) assert len(node_order) == node_order_size, 'Node order length is correct.' # the respective no. of regions in each cortex # group_bound = [len(labels[key]) for key in labels.keys()] group_bound = [len(key.values()[0]) for key in labels] # yaml order fix group_bound = [0] + group_bound[::-1] + group_bound group_boundaries = [ sum(group_bound[:i + 1]) for i in range(len(group_bound)) ] # remove the first element of group_bound # make label colours such that each cortex is of one colour group_bound.pop(0) label_colors = [] for ind, rep in enumerate(group_bound): label_colors += [cortex_colors[ind]] * rep assert len(label_colors) == len( node_order), 'Number of colours do not match' # remove the last total sum of the list group_boundaries.pop() node_angles = circular_layout(orig_labels, node_order, start_pos=90, group_boundaries=group_boundaries) # the order of the node_colors must match that of orig_labels # therefore below reordering is necessary reordered_colors = [ label_colors[node_order.index(orig)] for orig in orig_labels ] # labels mode decides the labels printed for each of the nodes if labels_mode is 'blank': # show nothing, only the empty circle plot my_labels = ['' for orig in orig_labels] elif labels_mode is 'cortex_only': # show only the names of cortex areas on one representative node replacer = dict({ 'caudalanteriorcingulate': 'cingulate', 'insula': 'insula', 'parstriangularis': 'frontal', 'precuneus': 'parietal', 'lingual': 'occipital', 'transversetemporal': 'temporal' }) replaced_labels = [] for myl in orig_labels: if myl.split('-lh')[0] in replacer.keys(): replaced_labels.append(replacer[myl.split('-lh')[0]] + '-lh') elif myl.split('-rh')[0] in replacer.keys(): replaced_labels.append(replacer[myl.split('-rh')[0]] + '-rh') else: replaced_labels.append('') my_labels = replaced_labels else: # show all the node labels as originally given my_labels = orig_labels # Plot the graph using node_order and colours # orig_labels is the order of nodes in the con matrix (important) fig, axes = plot_connectivity_circle(con, my_labels, n_lines=n_lines, facecolor='white', textcolor='black', node_angles=node_angles, colormap=colormap, node_colors=reordered_colors, node_edgecolor='white', fig=fig, fontsize_title=12, fontsize_names=10, padding=2., vmax=vmax, vmin=vmin, colorbar_size=0.2, colorbar_pos=colorbar_pos, colorbar=colorbar, show=show, subplot=subplot, indices=indices, title=title, **kwargs) if include_legend: import matplotlib.patches as mpatches # yaml order fix legend_patches = [ mpatches.Patch(color=col, label=llab.keys()[0]) for col, llab in zip(['g', 'r', 'c', 'y', 'b', 'm'], labels) ] # legend_patches = [mpatches.Patch(color=col, label=key) # for col, key in zip(['g', 'r', 'c', 'y', 'b', 'm'], # labels.keys())] plt.legend(handles=legend_patches, loc=3, ncol=1, mode=None, fontsize='medium') if tight_layout: fig.tight_layout() if out_fname: fig.savefig(out_fname, facecolor='white', dpi=600, bbox_inches=bbox_inches) return fig