def test_plot_connectivity_circle():
"""Test plotting connectivity circle
"""
node_order = ['frontalpole-lh', 'parsorbitalis-lh', 'lateralorbitofrontal-lh', 'rostralmiddlefrontal-lh', 'medialorbitofrontal-lh', 'parstriangularis-lh', 'rostralanteriorcingulate-lh', 'temporalpole-lh', 'parsopercularis-lh', 'caudalanteriorcingulate-lh', 'entorhinal-lh', 'superiorfrontal-lh', 'insula-lh', 'caudalmiddlefrontal-lh', 'superiortemporal-lh', 'parahippocampal-lh', 'middletemporal-lh', 'inferiortemporal-lh', 'precentral-lh', 'transversetemporal-lh', 'posteriorcingulate-lh', 'fusiform-lh', 'postcentral-lh', 'bankssts-lh', 'supramarginal-lh', 'isthmuscingulate-lh', 'paracentral-lh', 'lingual-lh', 'precuneus-lh', 'inferiorparietal-lh', 'superiorparietal-lh', 'pericalcarine-lh', 'lateraloccipital-lh', 'cuneus-lh', 'cuneus-rh', 'lateraloccipital-rh', 'pericalcarine-rh', 'superiorparietal-rh', 'inferiorparietal-rh', 'precuneus-rh', 'lingual-rh', 'paracentral-rh', 'isthmuscingulate-rh', 'supramarginal-rh', 'bankssts-rh', 'postcentral-rh', 'fusiform-rh', 'posteriorcingulate-rh', 'transversetemporal-rh', 'precentral-rh', 'inferiortemporal-rh', 'middletemporal-rh', 'parahippocampal-rh', 'superiortemporal-rh', 'caudalmiddlefrontal-rh', 'insula-rh', 'superiorfrontal-rh', 'entorhinal-rh', 'caudalanteriorcingulate-rh', 'parsopercularis-rh', 'temporalpole-rh', 'rostralanteriorcingulate-rh', 'parstriangularis-rh', 'medialorbitofrontal-rh', 'rostralmiddlefrontal-rh', 'lateralorbitofrontal-rh', 'parsorbitalis-rh', 'frontalpole-rh']
label_names = ['bankssts-lh', 'bankssts-rh', 'caudalanteriorcingulate-lh', 'caudalanteriorcingulate-rh', 'caudalmiddlefrontal-lh', 'caudalmiddlefrontal-rh', 'cuneus-lh', 'cuneus-rh', 'entorhinal-lh', 'entorhinal-rh', 'frontalpole-lh', 'frontalpole-rh', 'fusiform-lh', 'fusiform-rh', 'inferiorparietal-lh', 'inferiorparietal-rh', 'inferiortemporal-lh', 'inferiortemporal-rh', 'insula-lh', 'insula-rh', 'isthmuscingulate-lh', 'isthmuscingulate-rh', 'lateraloccipital-lh', 'lateraloccipital-rh', 'lateralorbitofrontal-lh', 'lateralorbitofrontal-rh', 'lingual-lh', 'lingual-rh', 'medialorbitofrontal-lh', 'medialorbitofrontal-rh', 'middletemporal-lh', 'middletemporal-rh', 'paracentral-lh', 'paracentral-rh', 'parahippocampal-lh', 'parahippocampal-rh', 'parsopercularis-lh', 'parsopercularis-rh', 'parsorbitalis-lh', 'parsorbitalis-rh', 'parstriangularis-lh', 'parstriangularis-rh', 'pericalcarine-lh', 'pericalcarine-rh', 'postcentral-lh', 'postcentral-rh', 'posteriorcingulate-lh', 'posteriorcingulate-rh', 'precentral-lh', 'precentral-rh', 'precuneus-lh', 'precuneus-rh', 'rostralanteriorcingulate-lh', 'rostralanteriorcingulate-rh', 'rostralmiddlefrontal-lh', 'rostralmiddlefrontal-rh', 'superiorfrontal-lh', 'superiorfrontal-rh', 'superiorparietal-lh', 'superiorparietal-rh', 'superiortemporal-lh', 'superiortemporal-rh', 'supramarginal-lh', 'supramarginal-rh', 'temporalpole-lh', 'temporalpole-rh', 'transversetemporal-lh', 'transversetemporal-rh']
node_angles = circular_layout(label_names, node_order, start_pos=90)
con = np.random.randn(68, 68)
plot_connectivity_circle(con, label_names, n_lines=300,
node_angles=node_angles, title='test')
def test_plot_connectivity_circle():
"""Test plotting connectivity circle
"""
node_order = [
'frontalpole-lh', 'parsorbitalis-lh', 'lateralorbitofrontal-lh',
'rostralmiddlefrontal-lh', 'medialorbitofrontal-lh',
'parstriangularis-lh', 'rostralanteriorcingulate-lh',
'temporalpole-lh', 'parsopercularis-lh', 'caudalanteriorcingulate-lh',
'entorhinal-lh', 'superiorfrontal-lh', 'insula-lh',
'caudalmiddlefrontal-lh', 'superiortemporal-lh', 'parahippocampal-lh',
'middletemporal-lh', 'inferiortemporal-lh', 'precentral-lh',
'transversetemporal-lh', 'posteriorcingulate-lh', 'fusiform-lh',
'postcentral-lh', 'bankssts-lh', 'supramarginal-lh',
'isthmuscingulate-lh', 'paracentral-lh', 'lingual-lh', 'precuneus-lh',
'inferiorparietal-lh', 'superiorparietal-lh', 'pericalcarine-lh',
'lateraloccipital-lh', 'cuneus-lh', 'cuneus-rh', 'lateraloccipital-rh',
'pericalcarine-rh', 'superiorparietal-rh', 'inferiorparietal-rh',
'precuneus-rh', 'lingual-rh', 'paracentral-rh', 'isthmuscingulate-rh',
'supramarginal-rh', 'bankssts-rh', 'postcentral-rh', 'fusiform-rh',
'posteriorcingulate-rh', 'transversetemporal-rh', 'precentral-rh',
'inferiortemporal-rh', 'middletemporal-rh', 'parahippocampal-rh',
'superiortemporal-rh', 'caudalmiddlefrontal-rh', 'insula-rh',
'superiorfrontal-rh', 'entorhinal-rh', 'caudalanteriorcingulate-rh',
'parsopercularis-rh', 'temporalpole-rh', 'rostralanteriorcingulate-rh',
'parstriangularis-rh', 'medialorbitofrontal-rh',
'rostralmiddlefrontal-rh', 'lateralorbitofrontal-rh',
'parsorbitalis-rh', 'frontalpole-rh'
]
label_names = [
'bankssts-lh', 'bankssts-rh', 'caudalanteriorcingulate-lh',
'caudalanteriorcingulate-rh', 'caudalmiddlefrontal-lh',
'caudalmiddlefrontal-rh', 'cuneus-lh', 'cuneus-rh', 'entorhinal-lh',
'entorhinal-rh', 'frontalpole-lh', 'frontalpole-rh', 'fusiform-lh',
'fusiform-rh', 'inferiorparietal-lh', 'inferiorparietal-rh',
'inferiortemporal-lh', 'inferiortemporal-rh', 'insula-lh', 'insula-rh',
'isthmuscingulate-lh', 'isthmuscingulate-rh', 'lateraloccipital-lh',
'lateraloccipital-rh', 'lateralorbitofrontal-lh',
'lateralorbitofrontal-rh', 'lingual-lh', 'lingual-rh',
'medialorbitofrontal-lh', 'medialorbitofrontal-rh',
'middletemporal-lh', 'middletemporal-rh', 'paracentral-lh',
'paracentral-rh', 'parahippocampal-lh', 'parahippocampal-rh',
'parsopercularis-lh', 'parsopercularis-rh', 'parsorbitalis-lh',
'parsorbitalis-rh', 'parstriangularis-lh', 'parstriangularis-rh',
'pericalcarine-lh', 'pericalcarine-rh', 'postcentral-lh',
'postcentral-rh', 'posteriorcingulate-lh', 'posteriorcingulate-rh',
'precentral-lh', 'precentral-rh', 'precuneus-lh', 'precuneus-rh',
'rostralanteriorcingulate-lh', 'rostralanteriorcingulate-rh',
'rostralmiddlefrontal-lh', 'rostralmiddlefrontal-rh',
'superiorfrontal-lh', 'superiorfrontal-rh', 'superiorparietal-lh',
'superiorparietal-rh', 'superiortemporal-lh', 'superiortemporal-rh',
'supramarginal-lh', 'supramarginal-rh', 'temporalpole-lh',
'temporalpole-rh', 'transversetemporal-lh', 'transversetemporal-rh'
]
node_angles = circular_layout(label_names, node_order, start_pos=90)
con = np.random.randn(68, 68)
plot_connectivity_circle(con,
label_names,
n_lines=300,
node_angles=node_angles,
title='test')
def _run_interface(self, runtime):
from nilearn.input_data import NiftiLabelsMasker
from nilearn.connectome import ConnectivityMeasure
from sklearn.covariance import EmpiricalCovariance
import numpy as np
import pandas as pd
import os
import matplotlib.pyplot as plt
from mne.viz import plot_connectivity_circle
import re
plt.switch_backend('Agg')
# extract timeseries from every label
masker = NiftiLabelsMasker(labels_img=self.inputs.atlas_file,
standardize=True, verbose=1)
timeseries = masker.fit_transform(self.inputs.timeseries_file)
# create correlation matrix
correlation_measure = ConnectivityMeasure(cov_estimator=EmpiricalCovariance(),
kind="correlation")
correlation_matrix = correlation_measure.fit_transform([timeseries])[0]
np.fill_diagonal(correlation_matrix, np.NaN)
# add the atlas labels to the matrix
atlas_lut_df = pd.read_csv(self.inputs.atlas_lut, sep='\t')
regions = atlas_lut_df['regions'].values
correlation_matrix_df = pd.DataFrame(correlation_matrix, index=regions, columns=regions)
# do a fisher's r -> z transform
fisher_z_matrix_df = correlation_matrix_df.apply(lambda x: (np.log(1 + x) - np.log(1 - x)) * 0.5)
# write out the file.
out_file = os.path.join(runtime.cwd, 'fisher_z_correlation.tsv')
fisher_z_matrix_df.to_csv(out_file, sep='\t', na_rep='n/a')
# save the filename in the outputs
self._results['correlation_matrix'] = out_file
# visualizations with mne
connmat = fisher_z_matrix_df.values
labels = list(fisher_z_matrix_df.index)
# define title and outfile names:
trial_regex = re.compile(r'.*trialtype-(?P<trial>[A-Za-z0-9]+)')
title = re.search(trial_regex, self.inputs.timeseries_file).groupdict()['trial']
outfile = os.path.join(runtime.cwd, ".".join([title, "svg"]))
n_lines = int(np.sum(connmat > 0) / 2)
fig = plt.figure(figsize=(5, 5))
plot_connectivity_circle(connmat, labels, n_lines=n_lines, fig=fig, title=title, fontsize_title=10,
facecolor='white', textcolor='black', colormap='jet', colorbar=1,
node_colors=['black'], node_edgecolor=['white'], show=False, interactive=False)
fig.savefig(outfile, dpi=300)
self._results['correlation_fig'] = outfile
return runtime
def plot_circular_connectivity(conmat, label_names, node_colors, node_order, vmin = 0.3, vmax = 1.0, nb_lines = 200, fname = "_def"):
import os
import numpy as np
from mne.viz import circular_layout, plot_connectivity_circle
import matplotlib.pyplot as plt
# Angles
node_angles = circular_layout(label_names, node_order, start_pos=90,
group_boundaries=[0, len(label_names) / 2])
# Plot the graph using node colors from the FreeSurfer parcellation. We only
# show the 300 strongest connections.
fig,_ = plot_connectivity_circle(conmat,
label_names,
n_lines=nb_lines,
node_angles=node_angles,
node_colors = node_colors,
fontsize_names = 12,
title='All-to-All Connectivity' ,
show = False,
vmin = vmin,
vmax = vmax)
#plot_conmat_file = os.path.abspath('circle.png')
plot_conmat_file = os.path.abspath('circle_' + fname + '.eps')
fig.savefig(plot_conmat_file, facecolor='black')
plt.close(fig)
#fig1.close()
del fig
return plot_conmat_file
def _plot_circular_connectivity(conmat,
label_names,
node_colors=None,
node_order=[],
vmin=0.3,
vmax=1.0,
nb_lines=200,
fname="_def",
save_dir=None):
"""Plot circular connectivity."""
import matplotlib.pyplot as plt
assert len(conmat.shape) == 2, "Error, conmat should be 2D matrix"
assert conmat.shape[0] == conmat.shape[1], "Error, conmat should squared"
assert conmat.shape[0] == len(label_names), "Error, conmat and labels\
should have same length {} != {}".format(conmat.shape[0],
len(label_names))
# if not defined, use label_names
if len(node_order) == 0:
node_order = label_names
# Angles
node_angles = circular_layout(label_names,
node_order,
start_pos=90,
group_boundaries=[0, len(label_names) / 2])
# necessary to have symetric matrix
conmat = conmat + np.transpose(conmat)
# Plot the graph
fig, _ = plot_connectivity_circle(conmat,
label_names,
n_lines=nb_lines,
node_angles=node_angles.astype(int),
node_colors=None,
fontsize_names=12,
title='All-to-All Connectivity',
show=False,
vmin=vmin,
vmax=vmax)
# saving circle file
if save_dir is not None:
assert os.path.exists(save_dir), ("Error, do not use save_dir if it \
does not exists before")
plot_conmat_file = os.path.join(save_dir, 'circle_' + fname + '.png')
else:
plot_conmat_file = os.path.abspath('circle_' + fname + '.png')
fig.savefig(plot_conmat_file, facecolor='black')
plt.close(fig)
return plot_conmat_file
def plot_circular_connectivity(conmat,
label_names,
node_colors,
node_order,
vmin=0.3,
vmax=1.0,
nb_lines=200,
fname="_def"):
"""Plot circular connectivity"""
import os
import numpy as np
from mne.viz import circular_layout, plot_connectivity_circle
import matplotlib.pyplot as plt
# Angles
node_angles = circular_layout(label_names,
node_order,
start_pos=90,
group_boundaries=[0, len(label_names) / 2])
print(conmat)
print((node_angles.astype(int)))
conmat = conmat + np.transpose(conmat)
# Plot the graph using node colors from the FreeSurfer parcellation.
# We only show the 300 strongest connections.
fig, _ = plot_connectivity_circle(conmat,
label_names,
n_lines=nb_lines,
node_angles=node_angles.astype(int),
node_colors=None,
fontsize_names=12,
title='All-to-All Connectivity',
show=False,
vmin=vmin,
vmax=vmax)
# plt.show()
# print fig
# plot_conmat_file = os.path.abspath('circle.png')
plot_conmat_file = os.path.abspath('circle_' + fname + '.eps')
fig.savefig(plot_conmat_file, facecolor='black')
# fig.savefig(plot_conmat_file)
plt.close(fig)
# fig1.close()
del fig
return plot_conmat_file
def test_plot_connectivity_circle():
"""Test plotting connectivity circle."""
node_order = ['aaa', 'bbb', 'ccc', 'ddd', 'eee', 'fff']
label_names = ['aaa', 'bbb', 'ccc', 'ddd', 'eee', 'fff']
group_boundaries = [0, 2, 4]
node_angles = circular_layout(label_names,
node_order,
start_pos=90,
group_boundaries=group_boundaries)
con = np.random.RandomState(0).randn(6, 6)
con[con < 0.7] = 0
fig, ax = plot_connectivity_circle(con,
label_names,
n_lines=60,
node_angles=node_angles,
title='test',
colormap='RdBu_r',
vmin=0,
vmax=2,
linewidth=.5,
facecolor='k')
plt.show()
pytest.raises(ValueError,
circular_layout,
label_names,
node_order,
group_boundaries=[-1])
pytest.raises(ValueError,
circular_layout,
label_names,
node_order,
group_boundaries=[20, 0])
# Save the plot order and create a circular layout
label_names=channel_names
node_order = list()
node_order=label_names
node_angles = circular_layout(label_names, node_order, start_pos=90,
group_boundaries=[0, len(label_names) / 2])
con_res=con_res.reshape(20,20)
if condition<3:
con_res1=con_res1.reshape(20,20)
dif=con_res1-con_res
dif1=con_res-con_res1 #checking for difference between the two
#Plotting connectivity
plot_connectivity_circle(con_res, label_names, n_lines=300,
node_angles=node_angles, node_colors=label_colors,vmin=0.4,
title='Connectivity, Condition: PLI '+Event+' '+ frequency+'P')
if condition<3:
plot_connectivity_circle(con_res1, label_names, n_lines=300,
node_angles=node_angles, node_colors=label_colors,vmin=0.4,
title='Connectivity, Condition: PLI '+Event+' '+ frequency+'NP')
if condition<3:
#Plotting connections that have difference
plot_connectivity_circle(dif, label_names, n_lines=300,
node_angles=node_angles, node_colors=label_colors, vmin=0.05,
title='Connectivity, Condition: PLI '+Event+' '+ frequency+'+')
plot_connectivity_circle(dif, label_names, n_lines=300,
node_angles=node_angles, node_colors=label_colors, vmin=0.05,
# For the right hemi
rh_labels = [label[:-2] + 'rh' for label in lh_labels]
# 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)
node_angles = circular_layout(label_names, node_order, start_pos=90,
group_boundaries=[0, len(label_names) / 2])
# Plot the graph using node colors from the FreeSurfer parcellation. We only
# show the 300 strongest connections.
fig,ax = plot_connectivity_circle(con_res['wpli2_debiased'], label_names, n_lines=300,
node_angles=node_angles, node_colors=label_colors,
title='All-to-All Connectivity Gamma Gratings '
'Condition (w-PLI)')
plt.savefig('circle.png', facecolor='black')
# Plot connectivity for both methods in the same plot
fig = plt.figure(num=None, figsize=(8, 4), facecolor='black')
no_names = [''] * len(label_names)
for ii, method in enumerate(con_methods):
plot_connectivity_circle(con_res[method], no_names, n_lines=300,
node_angles=node_angles, node_colors=label_colors,
title=method, padding=0, fontsize_colorbar=6,
fig=fig, subplot=(1, 2, ii + 1))
plt.show(block=True)
def make_circle(authors_df, label_names):
## Prep all labels, colors, etc
# Create node colors
types_colors = [ncol[0]] * len(type_labels)
mm_colors = [ncol[1]] * len(authors_df.loc[authors_df['GendCat'] == 'MM', 'CitationKey'])
mw_colors = [ncol[2]] * len(authors_df.loc[authors_df['GendCat'] == 'MW', 'CitationKey'])
wm_colors = [ncol[3]] * len(authors_df.loc[authors_df['GendCat'] == 'WM', 'CitationKey'])
ww_colors = [ncol[4]] * len(authors_df.loc[authors_df['GendCat'] == 'WW', 'CitationKey'])
u_colors = [ncol[5]] * len(authors_df.loc[authors_df['GendCat'].str.contains(r'U'), 'CitationKey'])
# LABEL COLORS GO IN THE ORIGINAL/MATRIX ORDER , not the reordered order!
label_colors = types_colors + mm_colors + mw_colors + wm_colors + ww_colors + u_colors
# MAKE NODE ORDER TO MAKE THE CIRCLE LOOK NICER - Node order is ONLY on the circle, not the matrix order.
pre_labels = ['Man - Man','Man - Woman','Spacer1']
post_labels = ['Spacer2','Woman - Man','Woman - Woman','Unknown']
# This node order is for the graph only! (ordered from starting point counter clockwise)
node_order = pre_labels + papers_label_list + post_labels
# now clean node order remove spacer labels only for graphing (angles needs all to be unique and match matrix)
cleaned_label_names = [' ' if 'Spacer' in i else i for i in label_names]
# Optional(?) clean paper titles for better looking graph
cleaned_titles = []
for paper in cleaned_label_names:
x = re.split('(\d+)',paper)
if len(x) == 3:
cleaned_titles.append(f'{x[0]} ({x[1]})')
else:
cleaned_titles.append(paper)
logger.debug(f'\n-Cleaned titles list: {cleaned_titles}\n')
## PREP FIGURE ##
fig = plt.figure(figsize=(30, 30), facecolor='black')
## MAKE NODES ANGLES ##
sp = 90
node_angles = circular_layout(label_names, node_order, start_pos=sp)
## Make custom colormap (if used)
cmap = colors.ListedColormap(['black',
ccol[0],ccol[1],
ccol[2],ccol[3],
ccol[4]])
boundaries = [0, 1, 2, 3, 4, 5]
norm = colors.BoundaryNorm(boundaries, cmap.N, clip=True)
# Make Custom/Manual Legend
MM_patch = mpatches.Patch(facecolor=ncol[1], label='Man / Man', linewidth = 1, edgecolor = 'black')
MW_patch = mpatches.Patch(facecolor=ncol[2], label='Man / Woman', linewidth = 1, edgecolor = 'black')
WM_patch = mpatches.Patch(facecolor=ncol[3], label='Woman / Man', linewidth = 1, edgecolor = 'black')
WW_patch = mpatches.Patch(facecolor=ncol[4], label='Woman / Woman', linewidth = 1, edgecolor = 'black')
U_patch = mpatches.Patch(facecolor=ncol[5], label='Unknown', linewidth = 1, edgecolor = 'black')
legend = plt.gcf().legend(handles=[MM_patch,MW_patch,WM_patch,WW_patch,U_patch],
loc=1, facecolor=args.lcol, framealpha=.98, prop={'size':35},
fancybox=True, title='Citation Type',title_fontsize=40)
# change legen color text?
# plt.setp(legend.get_texts(), color='g')
## Create Circle Graph
plot_connectivity_circle(cite_mat, cleaned_titles,
node_angles=node_angles,
node_colors=label_colors,
title=title, padding=4, fontsize_title=48,
textcolor='white', facecolor='black',
colormap=cmap, colorbar=False, fig=fig,
linewidth=4, fontsize_names=25,
subplot=111,
interactive=False, show=False
)
## SAVE FIGURE ##
out_fig = os.path.abspath(os.path.join(args.out_dir,png_name))
# have to re-set the facecolor before saving #
fig.savefig(out_fig, facecolor='black')
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)
# Compute connectivity for band containing the evoked response.
# We exclude the baseline period
# Delta 0 - 4
# Theta 4 - 7
# Alfa 7 - 14
# Beta 14 -21
# Gamma >30
# fmin, fmax = 3., 9.
fmin, fmax = 4., 7.
sfreq = raw.info['sfreq'] # the sampling frequency
tmin = 0.0 # exclude the baseline period
method = 'pli'
# method = 'pli'
con, freqs, times, n_epochs, n_tapers = spectral_connectivity(
epochs, method=method, mode='multitaper', sfreq=sfreq, fmin=fmin, fmax=fmax,
faverage=True, tmin=tmin, mt_adaptive=False, n_jobs=1)
# ******** PLOT ******** #
label_names = ['C3', 'C4', 'F3', 'F4', 'P3', 'P4'] # Orden original
node_order = ['F3', 'C3', 'P3', 'P4', 'C4', 'F4']
node_angles = circular_layout(label_names, node_order, start_pos=90,
group_sep=20,group_boundaries=[0, len(label_names) / 2])
plot_connectivity_circle(con[:, :, 0],label_names,node_angles=node_angles,
title=f'All-to-All Connectivity ({method})')
# %%
rh_labels = [label[:-2] + 'rh' for label in lh_labels]
# 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)
node_angles = circular_layout(label_names, node_order, start_pos=90,
group_boundaries=[0, len(label_names) / 2])
# Plot the graph using node colors from the FreeSurfer parcellation. We only
# show the 300 strongest connections.
plot_connectivity_circle(grand_con, label_names, n_lines=300,
node_angles=node_angles, node_colors=label_colors,vmin = 0.50, vmax = 1.00,
title='All-to-All Connectivity(PLV)- Grand Average - ' + freq)
import matplotlib.pyplot as plt
plt.savefig(conAll_plot_fname, facecolor='black')
plt.show()
## Plot connectivity for both methods in the same plot
#fig = plt.figure(num=None, figsize=(8, 4), facecolor='black')
#no_names = [''] * len(label_names)
#for ii, method in enumerate(con_methods):
# plot_connectivity_circle(con_res[method], no_names, n_lines=300,
# node_angles=node_angles, node_colors=label_colors,
# title=method, padding=0, fontsize_colorbar=6,
# fig=fig, subplot=(1, 2, ii + 1))
#plt.savefig('/home/custine/MEG/data/epi_conn/' + subj + '/coh/' + subj + '_circle_coh_imcoh_' + freq + '.png', facecolor='black')
##plt.show()
# 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)
node_angles = circular_layout(label_names, node_order, start_pos=90,
group_boundaries=[0, len(label_names) / 2])
# <codecell>
# Plot the graph using node colors from the FreeSurfer parcellation. We only
# show the 300 strongest connections.
fig1 = plt.figure(figsize=(20,20))
plot_connectivity_circle(con_res['pli'], label_names, n_lines=300, fontsize_names= 16, colormap='PiYG',
node_angles=node_angles2, node_colors=label_colors, fig = fig1,
title='All-to-All Connectivity left-Auditory '
'Condition (PLI)')
plt.show()
# <codecell>
plt.imshow(con_res['pli'][0::6,0::6])
con_res['pli'][0::6,0::6].shape
# <codecell>
import pandas as pd
df = pd.read_csv(r'C:\Users\lenovo\Documents//middle_east_data2.csv', header=0,index_col=0)
# <codecell>
# Get the y-location of the label
label_ypos_lh = list()
for name in lh_labels:
idx = label_names.index(name)
ypos = np.mean(labels_parc[idx].pos[:, 1])
label_ypos_lh.append(ypos)
# Reorder the labels based on their location
lh_labels = [label for (yp, label) in sorted(zip(label_ypos_lh, lh_labels))]
# For the right hemi
rh_labels = [label[:-2] + 'rh' for label in lh_labels]
# Save the plot order
node_order = lh_labels[::-1] + rh_labels
node_angles = circular_layout(label_names,
node_order,
start_pos=90,
group_boundaries=[0, len(label_names) // 2])
conmat = con[:, :, 0]
fig = plt.figure(num=None, figsize=(8, 8), facecolor='black')
plot_connectivity_circle(conmat,
label_names,
n_lines=300,
node_angles=node_angles,
node_colors=node_colors,
title='All-to-All Connectivity 300 Condition (PLI)',
fig=fig)
label_colors = [labels for label in labels]
labels[1][0]
node_angles = circular_layout(labels, labels, group_boundaries = boundaries)
fig = plt.figure(figsize=(20,20))
plot_connectivity_circle(corr_chans, labels,
node_angles=node_angles,
node_colors=[(.5,.5,.5, 1)],
facecolor = [0.1,0.1,0.1],
node_edgecolor=[0.1,0.1,0.1],
textcolor=[1,1,1],
fontsize_names = 10,
colormap='viridis',
vmin=np.min(corr_chans),
vmax = np.max(corr_chans),
linewidth = 1.5, fig=fig)
, fig=fig
vmax = np.max(corr_chans[corr_chans < 1]),
plot_connectivity_circle(corr_chans, labels,
node_angles=node_angles,
node_colors = [(.5, .5, .5, 1)],
facecolor = [0.1, 0.1, 0.1],
node_edgecolor = [0.1, 0.1, 0.1],
linewidth = 1.5)
print 'Jane Here'
print
print node_order
print len(node_order)
node_angles = circular_layout(label_names, node_order, start_pos=90,
group_boundaries=[0, len(label_names) / 2])
#############################################################################################
#########Plot the difference
##############3
# Plot the graph using node colors from the FreeSurfer parcellation. We only
# show the 300 strongest connections.
plot_connectivity_circle(con_diff_temp, label_names, n_lines=300,
node_angles=node_angles, node_colors=label_colors,colormap = 'RdBu', vmin = -1, vmax = 1,
title='Coherence - Difference ('+ gp1 + '-' +gp2 +') - '+ freq)
import matplotlib.pyplot as plt
plt.savefig(conAll_diff_plot_fname, facecolor='black')
plt.show()
###########################################################################################
###########Plot the connectivity T stats - 2 sample
## Plot the graph using node colors from the FreeSurfer parcellation. We only
## show the 300 strongest connections.
#plot_connectivity_circle(con_t_temp, label_names, n_lines=200,
# node_angles=node_angles, node_colors=label_colors,colormap = 'Blues', vmin = 1, vmax = 5.0,
# title='Coherence - T stats - Positive ('+ gp1 + '-' +gp2 +') - '+ freq)
#import matplotlib.pyplot as plt
#plt.savefig(conAll_Tpos_plot_fname, facecolor='black')
#plot_connectivity_circle(con_t_temp, label_names, n_lines=200,
# node_angles=node_angles, node_colors=label_colors,colormap = 'Reds', vmin = -5, vmax = -1,
node_angles = circular_layout(label_names,
node_order,
start_pos=90,
group_boundaries=[0, len(label_names) / 2])
# Plot the graph using node colors from the FreeSurfer parcellation. We only
# show the 200 strongest connections.
plt.ion()
fig = plt.figure(num=None, figsize=(8, 4), facecolor='black')
plot_connectivity_circle(leakage_mne,
label_names,
n_lines=200,
node_angles=node_angles,
node_colors=label_colors,
title='MNE Leakage',
fig=fig,
subplot=(1, 2, 1))
no_names = [''] * len(label_names)
plot_connectivity_circle(leakage_lor,
no_names,
n_lines=200,
node_angles=node_angles,
node_colors=label_colors,
title='sLORETA Leakage',
padding=0,
fontsize_colorbar=6,
fig=fig,
(0.39215686274509803, 0.39803921568627451, 0.0, 1.0),
(0.00215686274509803, 0.39803921568627451, 0.0, 1.0),
(0.0, 0.39803921568627451, 0.4, 1.0), (0.0, 0.39803921568627451, 0.4, 1.0),
(0.4, 0.0, 0.4, 1.0), (0.4, 0.2, 0.4, 1.0), (0.4, 0.4, 0.0, 1.0),
(0.4, 0.2, 0.0, 1.0), (0.2, 0.0, 0.4, 1.0), (0.2, 0.2, 0.4, 1.0),
(0.2, 0.4, 0.0, 1.0), (0.4, 0.0, 0.0, 1.0), (0.8, 0.2, 0.0, 1.0),
(0.8, 0.0, 0.4, 1.0), (0.2, 0.8, 0.4, 1.0), (0.2, 0.8, 0.0, 1.0),
(0.4, 0.0, 0.8, 1.0)
]
fig = plt.figure(num=None, figsize=(9, 9), facecolor='black')
plot_connectivity_circle(data_PLV1,
label_name,
n_lines=12,
facecolor='black',
textcolor='white',
vmin=np.min(data_PLV1),
vmax=np.max(data_PLV1),
node_angles=node_angles,
linewidth=3,
node_colors=label_colors,
fig=fig,
padding=6,
fontsize_colorbar=15,
colorbar_size=0.7,
colorbar_pos=(-0.3, 0.5),
colormap='hot',
fontsize_title=12,
fontsize_names=15)
plt.show()
fig.savefig('adj_diff_third_4.png', dpi=1800, facecolor='black')
# Reorder the labels based on their location
lh_labels = [label for (ypos, label) in sorted(zip(label_ypos, lh_labels))]
print lh_labels
# For the right hemi
rh_labels = [label[:-2] + 'rh' for label in lh_labels]
print rh_labels
# 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)
node_angles = circular_layout(label_names, node_order, start_pos=90,
group_boundaries=[0, len(label_names) / 2])
# Plot the graph using node colors from the FreeSurfer parcellation. We only
# show the 300 strongest connections.
plot_connectivity_circle(con_res['plv'], label_names, n_lines=300, ##con_res['coh'] or con_res1 if reading directly from text file - see commented section above
node_angles=node_angles, node_colors=label_colors,
title='All-to-All Connectivity(PLV)-'+ freq, vmin = 0.40, vmax = 1.00)
import matplotlib.pyplot as plt
plt.savefig('/home/custine/MEG/data/epi_conn/' + subj + '/coh/' + subj + '_circle_PLV_' + freq + '.png', facecolor='black')
# Plot the graph using node colors from the FreeSurfer parcellation. We only
# show the 300 strongest connections.
plot_connectivity_circle(con_res['plv'], label_names, n_lines=300, ##con_res['coh'] or con_res1 if reading directly from text file - see commented section above
node_angles=node_angles, node_colors=label_colors,
title='All-to-All Connectivity(PLI)-'+ freq, vmin = 0.0, vmax = 1.00)
import matplotlib.pyplot as plt
plt.savefig('/home/custine/MEG/data/epi_conn/' + subj + '/coh/' + subj + '_circle_PLI_' + freq + '.png', facecolor='black')
def test_plot_connectivity_circle():
"""Test plotting connectivity circle."""
node_order = ['frontalpole-lh', 'parsorbitalis-lh',
'lateralorbitofrontal-lh', 'rostralmiddlefrontal-lh',
'medialorbitofrontal-lh', 'parstriangularis-lh',
'rostralanteriorcingulate-lh', 'temporalpole-lh',
'parsopercularis-lh', 'caudalanteriorcingulate-lh',
'entorhinal-lh', 'superiorfrontal-lh', 'insula-lh',
'caudalmiddlefrontal-lh', 'superiortemporal-lh',
'parahippocampal-lh', 'middletemporal-lh',
'inferiortemporal-lh', 'precentral-lh',
'transversetemporal-lh', 'posteriorcingulate-lh',
'fusiform-lh', 'postcentral-lh', 'bankssts-lh',
'supramarginal-lh', 'isthmuscingulate-lh', 'paracentral-lh',
'lingual-lh', 'precuneus-lh', 'inferiorparietal-lh',
'superiorparietal-lh', 'pericalcarine-lh',
'lateraloccipital-lh', 'cuneus-lh', 'cuneus-rh',
'lateraloccipital-rh', 'pericalcarine-rh',
'superiorparietal-rh', 'inferiorparietal-rh', 'precuneus-rh',
'lingual-rh', 'paracentral-rh', 'isthmuscingulate-rh',
'supramarginal-rh', 'bankssts-rh', 'postcentral-rh',
'fusiform-rh', 'posteriorcingulate-rh',
'transversetemporal-rh', 'precentral-rh',
'inferiortemporal-rh', 'middletemporal-rh',
'parahippocampal-rh', 'superiortemporal-rh',
'caudalmiddlefrontal-rh', 'insula-rh', 'superiorfrontal-rh',
'entorhinal-rh', 'caudalanteriorcingulate-rh',
'parsopercularis-rh', 'temporalpole-rh',
'rostralanteriorcingulate-rh', 'parstriangularis-rh',
'medialorbitofrontal-rh', 'rostralmiddlefrontal-rh',
'lateralorbitofrontal-rh', 'parsorbitalis-rh',
'frontalpole-rh']
label_names = ['bankssts-lh', 'bankssts-rh', 'caudalanteriorcingulate-lh',
'caudalanteriorcingulate-rh', 'caudalmiddlefrontal-lh',
'caudalmiddlefrontal-rh', 'cuneus-lh', 'cuneus-rh',
'entorhinal-lh', 'entorhinal-rh', 'frontalpole-lh',
'frontalpole-rh', 'fusiform-lh', 'fusiform-rh',
'inferiorparietal-lh', 'inferiorparietal-rh',
'inferiortemporal-lh', 'inferiortemporal-rh', 'insula-lh',
'insula-rh', 'isthmuscingulate-lh', 'isthmuscingulate-rh',
'lateraloccipital-lh', 'lateraloccipital-rh',
'lateralorbitofrontal-lh', 'lateralorbitofrontal-rh',
'lingual-lh', 'lingual-rh', 'medialorbitofrontal-lh',
'medialorbitofrontal-rh', 'middletemporal-lh',
'middletemporal-rh', 'paracentral-lh', 'paracentral-rh',
'parahippocampal-lh', 'parahippocampal-rh',
'parsopercularis-lh', 'parsopercularis-rh',
'parsorbitalis-lh', 'parsorbitalis-rh',
'parstriangularis-lh', 'parstriangularis-rh',
'pericalcarine-lh', 'pericalcarine-rh', 'postcentral-lh',
'postcentral-rh', 'posteriorcingulate-lh',
'posteriorcingulate-rh', 'precentral-lh', 'precentral-rh',
'precuneus-lh', 'precuneus-rh',
'rostralanteriorcingulate-lh',
'rostralanteriorcingulate-rh', 'rostralmiddlefrontal-lh',
'rostralmiddlefrontal-rh', 'superiorfrontal-lh',
'superiorfrontal-rh', 'superiorparietal-lh',
'superiorparietal-rh', 'superiortemporal-lh',
'superiortemporal-rh', 'supramarginal-lh',
'supramarginal-rh', 'temporalpole-lh', 'temporalpole-rh',
'transversetemporal-lh', 'transversetemporal-rh']
group_boundaries = [0, len(label_names) / 2]
node_angles = circular_layout(label_names, node_order, start_pos=90,
group_boundaries=group_boundaries)
con = np.random.RandomState(0).randn(68, 68)
plot_connectivity_circle(con, label_names, n_lines=300,
node_angles=node_angles, title='test',
)
pytest.raises(ValueError, circular_layout, label_names, node_order,
group_boundaries=[-1])
pytest.raises(ValueError, circular_layout, label_names, node_order,
group_boundaries=[20, 0])
plt.close('all')
plt.show()
# %%
# ******** PLOT ******** #
label_names = ['C3', 'C4', 'F3', 'F4', 'P3', 'P4'] # Orden original
node_order = ['F3', 'C3', 'P3', 'P4', 'C4', 'F4']
node_angles = circular_layout(label_names,
node_order,
start_pos=90,
group_sep=20,
group_boundaries=[0, len(label_names) / 2])
fig = plt.figure(num=None, figsize=(12, 7), facecolor='black')
plot_connectivity_circle(exp2_CR[2, :, :],
label_names,
node_angles=node_angles,
interactive=True,
fig=fig,
subplot=(1, 3, 1),
title='All-to-All Connectivity (CR)')
plot_connectivity_circle(exp2_IR[0, :, :],
label_names,
node_angles=node_angles,
interactive=True,
fig=fig,
subplot=(1, 3, 2),
title='All-to-All Connectivity (IR)')
plot_connectivity_circle(exp2_NR[0, :, :],
label_names,
node_angles=node_angles,
# For the right hemi
rh_labels = [label[:-2] + 'rh' for label in lh_labels]
# 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)
node_angles = circular_layout(label_names, node_order, start_pos=90,
group_boundaries=[0, len(label_names) / 2])
# Plot the graph using node colors from the FreeSurfer parcellation. We only
# show the 300 strongest connections.
plot_connectivity_circle(con_res['pli'], label_names, n_lines=300,
node_angles=node_angles, node_colors=label_colors,
title='All-to-All Connectivity left-Auditory '
'Condition (PLI)')
###############################################################################
# Make two connectivity plots in the same figure
# ----------------------------------------------
#
# We can also assign these connectivity plots to axes in a figure. Below we'll
# show the connectivity plot using two different connectivity methods.
fig = plt.figure(num=None, figsize=(8, 4), facecolor='black')
no_names = [''] * len(label_names)
for ii, method in enumerate(con_methods):
plot_connectivity_circle(con_res[method], no_names, n_lines=300,
node_angles=node_angles, node_colors=label_colors,
title=method, padding=0, fontsize_colorbar=6,
def plot_connectivity(fc: Union[np.ndarray, pd.DataFrame], threshold: Optional[float] = None, plot_style: str = 'heatmap',
bg_style: str = 'whitegrid', node_order: Optional[list] = None, auto_cluster: bool = False,
**kwargs) -> plt.Axes:
"""Plot functional connectivity between nodes in backend.
Parameters
----------
fc
Pandas dataframe containing or numpy array containing the functional connectivities.
threshold
Connectivtiy threshold to be applied (only connectivities larger than the threshold will be shown).
plot_style
Can either be `heatmap` for plotting with seaborn.heatmap or `circular_graph` for plotting with
mne.viz.plot_connectivity_circle. Check out the respective function docstrings for information on
their arguments (can be passed to kwargs).
bg_style
Only relevant if plot_style == heatmap. Then this will define the style of the background of the plot.
node_order
Order in which the nodes should appear in the plot.
auto_cluster
If true, automatic cluster detection will be used to arange the nodes
kwargs
Additional arguments for the fc calculation or fc plotting that can be passed.
Returns
-------
plt.Axes
Handle of the axis the plot was created in.
"""
import seaborn as sb
# turn fc into dataframe if necessary
if type(fc) is np.ndarray:
rows = kwargs.pop('yticklabels') if 'yticklabels' in kwargs.keys() else [str(i) for i in range(fc.shape[0])]
cols = kwargs.pop('xticklabels') if 'xticklabels' in kwargs.keys() else [str(i) for i in range(fc.shape[1])]
fc = pd.DataFrame(fc, index=[str(r) for r in rows], columns=[str(c) for c in cols])
# apply threshold
if threshold:
fc[fc < threshold] = 0.
# cluster the columns
#####################
if auto_cluster:
idx_r = [i for i in range(fc.shape[0])]
idx_c = [i for i in range(fc.shape[1])]
# Create a categorical color palette for node groups
col_pal_args = ['h', 's', 'l']
kwargs_tmp = {}
for key in kwargs.keys():
if key in col_pal_args:
kwargs_tmp[key] = kwargs.pop(key)
node_pal = sb.husl_palette(len(idx_c), **kwargs_tmp)
nodes = fc.columns.values
node_lut = dict(zip(map(str, nodes), node_pal))
# Convert the palette to vectors that will be drawn on the side of the fc plot
node_colors = pd.Series(nodes, index=fc.columns).map(node_lut)
elif node_order:
idx_c = [node_order.index(n) for n in fc.columns.values]
idx_r = [i for i in range(fc.shape[0])]
else:
idx_r = [i for i in range(fc.shape[0])]
idx_c = [i for i in range(fc.shape[1])]
fc = fc.iloc[idx_r, idx_c]
# plot the functional connectivities
####################################
# choose plot style
if plot_style == 'heatmap':
# seaborn plot
if 'xticklabels' not in kwargs:
kwargs['xticklabels'] = fc.columns.values[idx_c]
if 'yticklabels' not in kwargs:
kwargs['yticklabels'] = fc.index[idx_r]
sb.set_style(bg_style)
if auto_cluster:
ax = sb.clustermap(data=fc, row_colors=node_colors, col_colors=node_colors, **kwargs)
else:
ax = sb.heatmap(fc, **kwargs)
# ax.invert_yaxis()
elif plot_style == 'circular_graph':
# mne python plot
from mne.viz import circular_layout, plot_connectivity_circle
# get node order for node layout
node_names = fc.columns.values
if auto_cluster:
cluster_args = ['method', 'metric', 'z_score', 'standard_scale']
kwargs_tmp = {}
for key in kwargs.keys():
if key in cluster_args:
kwargs_tmp[key] = kwargs.pop(key)
clust_map = sb.clustermap(data=fc, row_colors=node_colors, col_colors=node_colors, **kwargs_tmp)
node_order = [node_names[idx] for idx in clust_map.dendrogram_row.reordered_ind]
elif not node_order:
node_order = list(node_names)
# create circular node layout
kwargs_tmp = {}
layout_args = ['start_pos', 'start_between', 'group_boundaries', 'group_sep']
for key in kwargs.keys():
if key in layout_args:
kwargs_tmp[key] = kwargs.pop(key)
node_angles = circular_layout(node_names, node_order, **kwargs_tmp)
# plot the circular graph
ax = plot_connectivity_circle(fc.values, node_names, node_angles=node_angles, **kwargs)
else:
raise ValueError(f'Plot style is not supported by this function: {plot_style}. Check the documentation of the '
f'argument `plot_style` for valid options.')
return ax
# Leakage matrix for MNE, get first principal component per label
for [i, s] in enumerate(stcs_psf_mne):
psfs_mat[i, :] = s.data[:, 0]
# Compute label-to-label leakage as Pearson correlation of PSFs
# Sign of correlation is arbitrary, so take absolute values
leakage_mne = np.abs(np.corrcoef(psfs_mat))
# Save the plot order and create a circular layout
node_order = lh_labels[::-1] + rh_labels # mirror label order across hemis
node_angles = circular_layout(label_names, node_order, start_pos=90,
group_boundaries=[0, len(label_names) / 2])
# Plot the graph using node colors from the FreeSurfer parcellation. We only
# show the 200 strongest connections.
fig = plt.figure(num=None, figsize=(8, 8), facecolor='black')
plot_connectivity_circle(leakage_mne, label_names, n_lines=200,
node_angles=node_angles, node_colors=label_colors,
title='MNE Leakage', fig=fig)
# %%
# Most leakage occurs for neighbouring regions, but also for deeper regions
# across hemispheres.
#
# Save the figure (optional)
# --------------------------
#
# Matplotlib controls figure facecolor separately for interactive display
# versus for saved figures. Thus when saving you must specify ``facecolor``,
# else your labels, title, etc will not be visible::
#
# >>> fname_fig = data_path + '/MEG/sample/plot_label_leakage.png'
# >>> fig.savefig(fname_fig, facecolor='black')
def circular_brain_plot(forward,
solution_support,
stcs,
obj_fun,
label_name=False,
plot_circular=True,
plot_labels=True,
n_burnin=0,
vmin=0.,
vmax=10.,
plot_hist=False,
subplot=111,
title='',
fig=None,
colorbar=True):
indices = list()
vertices_lh = list()
vertices_rh = list()
support = np.unique(np.where(solution_support)[1])
indices.append(support)
for stc in stcs:
vertices_lh.append(stc.vertices[0])
vertices_rh.append(stc.vertices[1])
indices = np.unique(np.concatenate(np.array(indices)))
vertices_lh = np.unique(np.concatenate(np.array(vertices_lh)))
vertices_rh = np.unique(np.concatenate(np.array(vertices_rh)))
n_sources = solution_support.shape[1]
# Get n_used of the left hemi
n_used = forward['src'][0]['nuse']
n_rh = forward['src'][1]['nuse']
#
indices_lh = indices[np.where(indices < n_used)[0]]
indices_rh = indices[np.where(indices >= n_used)[0]]
indices_sym = np.sort(
np.concatenate(
np.array([indices, indices_lh + n_used, indices_rh - n_rh])))
#
n_support = len(indices_sym)
iindices = [list(indices_sym).index(ii) for ii in indices]
# Remove burnin
solution_support = solution_support[n_burnin:, :]
stcs = stcs[n_burnin:]
# Plot histogram of the different objective function values
# obtained with the MCMC init after burnin.
if plot_hist:
out = plt.hist(obj_fun)
ymin, ymax = 0, out[0].max()
plt.vlines(obj_fun[0], ymin=ymin, ymax=ymax)
plt.ylim([ymin, ymax])
plt.yticks(fontsize=16)
plt.xticks(fontsize=16)
plt.xlabel('Objective function values', fontsize=16)
plt.legend(['MM solution', 'MCMC initializations'], fontsize=16)
plt.show()
# ####
ind = np.unique(np.where(solution_support)[1])
# ####
# Take the results for all indices
data_support_res = solution_support[:, indices]
# Construct cooeccurrence matrix
cooecc = np.zeros((n_sources, n_sources))
ixgrid = np.ix_(indices, indices)
cooecc[ixgrid] = np.dot(data_support_res.T, data_support_res)
ixgrid = np.ix_(indices_sym, indices_sym)
cooecc = cooecc[ixgrid]
# Read labels
# data_path = sample.data_path()
subjects_dir = sample.data_path() + '/subjects'
labels = mne.read_labels_from_annot('sample',
parc='aparc.split-125',
subjects_dir=subjects_dir)
# First, we reorder the labels based on their location in the left hemi
label_names = [label.name for label in labels]
lh_labels = [name for name in label_names if name.endswith('lh')]
# Get the y-location of the label
label_ypos = list()
for name in lh_labels:
idx = label_names.index(name)
ypos = np.mean(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))]
# Find the corresponding label name to the vertices
lh_names = list()
length = 0
for vertex in vertices_lh:
for label in labels[::2]:
if vertex in label.vertices:
lh_names.append(label.name)
if len(lh_names) != length + 1:
lh_names.append(labels[56].name)
length += 1
rh_names = list()
length = 0
for vertex in vertices_rh:
for label in labels[1::2]:
if vertex in label.vertices:
rh_names.append(label.name)
if len(rh_names) != length + 1:
rh_names.append(labels[57].name)
length += 1
names = lh_names + rh_names
names_sym = np.array([''] * n_support, dtype='U30')
names_sym[iindices] = names
for ii in np.where(names_sym == '')[0]:
if indices_sym[ii] < n_used:
ind = np.where(indices == indices_sym[ii] + n_rh)[0]
if ind.shape[0] == 0:
ind = np.where(indices == indices_sym[ii] - 2 + n_rh)[0]
name = np.array(names)[ind][0][:-3] + '-lh'
else:
ind = np.where(indices == indices_sym[ii] - n_used)[0]
if ind.shape[0] == 0:
ind = np.where(indices == indices_sym[ii] - 2 - n_used)[0]
name = np.array(names)[ind][0][:-3] + '-rh'
names_sym[ii] = name
names = names_sym
dipole_colors = list()
names_lh = list()
# For each found label find its color
for label in names:
if label[:-3] != 'n':
idx = label_names.index(label)
if labels[idx].color == (0., 0., 0., 1.):
labels[idx].color = (0.5, 0.5, 0.5, 1.)
dipole_colors.append(labels[idx].color)
names_lh.append(label[:-3])
else:
dipole_colors.append((0., 0., 0., 1.))
names_lh.append('none')
names_lh = names_lh[:n_support // 2]
seen_labels = list()
node_order = list()
# Find the good order for names and cooecc
for label in lh_labels:
if label not in seen_labels and label[:-3] in names_lh:
node_order.append(np.where(np.array(names_lh) == label[:-3])[0])
seen_labels.append(label)
lh_order = list(np.concatenate(np.array(node_order)))
node_order = lh_order[::-1]
# colors = list(np.array(dipole_colors)[node_order])
node_order.extend(list(np.array(lh_order) + len(lh_order)))
node_width = 2 * 180. / n_support
label_indices = range(n_support)
node_angles = circular_layout(label_indices,
node_order,
start_pos=90,
group_boundaries=[0,
len(label_indices) / 2])
dipole_colors = dipole_colors[:n_support // 2]
colors = np.concatenate(np.array([dipole_colors, dipole_colors]))
if not label_name:
names = np.array([''] * len(indices_sym), dtype=np.dtype((str, 35)))
if plot_circular:
fig, ax = plot_connectivity_circle(cooecc,
names,
n_lines=None,
node_angles=node_angles,
node_colors=colors,
node_width=node_width,
vmin=vmin,
vmax=vmax,
fig=fig,
subplot=subplot,
title=title,
padding=4,
textcolor='black',
facecolor='white',
colormap='viridis',
node_edgecolor=None,
colorbar=colorbar)
plot_bars_circular(n_support, node_angles, cooecc.diagonal(), ax)
if plot_labels:
brain_labels(labels, names_sym, subjects_dir)
def connectivity_circle(r, measure='coh',
pairs='all',
times=list(range(0, 501, 125)),
figure_by={'POP': ['C']},
row_by={'condition': 'all'},
lims='absmax', cmap_override=None,
savedir=None):
''' plot coherence as generic circle of nodes connected by colored arcs '''
ptype = 'arctopo'
final_dim = 'pair'
if measure in ['coh', 'coh_Z']:
data, d_dims, d_dimlvls = get_data(r, measure)
units, lims, cmap = get_plotparams(r, measure, lims, cmap_override)
else:
print('data not recognized')
return
f_dim, f_vals, f_lbls = handle_by(r, figure_by, d_dims, d_dimlvls)
r_dim, r_vals, r_lbls = handle_by(r, row_by, d_dims, d_dimlvls)
time_by = {'timepoint': times}
t_dim, t_vals, t_lbls = handle_by(r, time_by, d_dims, d_dimlvls)
pair_inds = handle_pairs(r, pairs)
pair_chaninds = [r.cohpair_inds[pi] for pi in pair_inds]
uniq_chaninds = np.unique(np.array(pair_chaninds).ravel())
uniq_chanlabels = [r.montage.ch_names[ci] for ci in uniq_chaninds]
uniq_chanlabels.sort(key=lambda x: ordered_chans.index(x))
cohpair_array = []
for chan_pair in np.array(r.cohpair_inds):
cohpair_array.append(
[uniq_chanlabels.index(r.montage.ch_names[int(chan_pair[0])]),
uniq_chanlabels.index(r.montage.ch_names[int(chan_pair[1])])])
cohpair_array = np.array(cohpair_array)
indices = (cohpair_array[:, 0], cohpair_array[:, 1])
pair_dim = d_dims.index('pair')
data = basic_slice(data, [(pair_dim, pair_inds)])
sp_dims = (len(r_vals), len(times))
figsize = figsize_heuristic(sp_dims)
for fi, fval in enumerate(f_vals):
f, axarr = plt.subplots(sp_dims[0], sp_dims[1],
sharex=True, sharey=True, figsize=figsize)
f.suptitle(f_lbls[fi], fontsize=titlefont_sz, fontweight=titlefont_wt)
try:
axarr = axarr.ravel()
except:
axarr = [axarr]
ax_dum = -1
for ri, rval in enumerate(r_vals):
for ti, tval in enumerate(t_vals):
vals = [fval, rval, tval]
dims = [f_dim[fi], r_dim[ri], t_dim[ti]]
# try:
dimval_tups = [(d, v) for d, v in zip(dims, vals)]
try:
arcs = basic_slice(data, dimval_tups)
print('slice')
except:
arcs = compound_take(data, dimval_tups)
print('compound take')
mean_dims = np.where([d != final_dim for d in d_dims])
arcs = arcs.mean(axis=tuple(mean_dims[0]))
print(arcs.shape)
ax_dum += 1
# column = (ax_dum + 1) % sp_dims[1]
# row = floor(ax_dum / sp_dims[1])
# plot here
plot_connectivity_circle(arcs, uniq_chanlabels, indices,
# node_angles=node_angles,
facecolor='white',
textcolor='black',
colormap=plt.cm.hot_r,
title='title',
colorbar_size=0.4,
colorbar_pos=(-0.5, 0.5),
fig=f,
subplot=(sp_dims[0], sp_dims[1], ax_dum + 1))
axarr[ax_dum].text(-.5, .5, t_lbls[ti]) # time label
if ti == 0:
axarr[ax_dum].text(-1.5, 0, r_lbls[ri]) # row label
if savedir:
save_fig(r, savedir, ptype, measure, f_lbls[fi])
# 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)
node_angles = circular_layout(label_names,
node_order,
start_pos=90,
group_boundaries=[0, len(label_names) / 2])
# Plot the graph using node colors from the FreeSurfer parcellation. We only
# show the 300 strongest connections.
plot_connectivity_circle(con_res['pli'],
label_names,
n_lines=300,
node_angles=node_angles,
node_colors=label_colors,
title='All-to-All Connectivity left-Auditory '
'Condition (PLI)')
plt.savefig('circle.png', facecolor='black')
# Plot connectivity for both methods in the same plot
fig = plt.figure(num=None, figsize=(8, 4), facecolor='black')
no_names = [''] * len(label_names)
for ii, method in enumerate(con_methods):
plot_connectivity_circle(con_res[method],
no_names,
n_lines=300,
node_angles=node_angles,
node_colors=label_colors,
title=method,
def make_circle(threshmat, outpath, label_names, thr):
## GET VMIN AND MAX FROM MATRIX
# maxval = threshmat.max()
# minval = np.min(threshmat[np.nonzero(threshmat)]) - 1
maxval = None
minval = None
## CHECK CIRCLE GRAPH COLOR TYPE ##
if color_type == 'DARK':
fc = 'black'
elif color_type == 'LIGHT':
fc = 'white'
## PREP FIGURE
fig = plt.figure(num=None, figsize=(30, 30), facecolor=fc)
## MAKE NODES ANGLES ##
node_angles = circular_layout(label_names,
node_order,
start_pos=sp,
group_boundaries=split)
## REMOVE NAMES IF TRUE ##
remove_names = True
if remove_names == True:
label_names = [''] * len(label_names)
## WRITE GRAPH TO FIG ##
if color_type == 'DARK':
plot_connectivity_circle(
threshmat,
label_names,
node_angles=node_angles,
node_colors=label_colors,
title=title,
fontsize_title=48,
textcolor='white',
facecolor='black',
node_edgecolor='black',
node_linewidth=.5,
linewidth=1.5,
fontsize_names=8,
colormap='hot',
vmin=minval,
vmax=maxval,
### make vmin and max the values from the min/max of matrix
colorbar_size=0.2,
colorbar_pos=(-1, .5),
fontsize_colorbar=28,
colorbar=True,
padding=6.0,
fig=fig,
subplot=111,
interactive=False,
show=False)
# ADD Left/Right Labels
plt.gcf().text(.22, .5, 'L', color='white', fontsize=48)
plt.gcf().text(.633, .5, 'R', color='white', fontsize=48)
elif color_type == 'LIGHT':
plot_connectivity_circle(
threshmat,
label_names,
node_angles=node_angles,
node_colors=label_colors,
title=title,
fontsize_title=48,
textcolor='black',
facecolor='white',
node_edgecolor='black',
node_linewidth=.5,
linewidth=1.5,
fontsize_names=8,
colormap='hot_r',
vmin=minval,
vmax=maxval, # colormap='YlGnBu'
### make vmin and max the values from the min/max of matrix
colorbar_size=0.2,
colorbar_pos=(-1, .5),
fontsize_colorbar=28,
colorbar=True,
padding=6.0,
fig=fig,
subplot=111,
interactive=False,
show=False)
# ADD Left/Right Labels
plt.gcf().text(.22, .5, 'L', color='black', fontsize=48)
plt.gcf().text(.633, .5, 'R', color='black', fontsize=48)
## SAVE FIGURE ##
out_fig = os.path.abspath(
os.path.join(out_path, file_name + '_THR' + str(thr)))
# have to re-set the facecolor before saving #
fig.savefig(out_fig, facecolor=fc)
# For the right hemi
rh_labels = [
label[:-2] + 'rh' for label in lh_labels
if label != 'Brain-Stem' and label[:-2] + 'rh' in rh_labels
]
# Save the plot order
node_order = list()
node_order = lh_labels[::-1] + rh_labels
node_angles = circular_layout(label_names,
node_order,
start_pos=90,
group_boundaries=[0, len(label_names) // 2])
# Plot the graph using node colors from the FreeSurfer parcellation. We only
# show the 300 strongest connections.
conmat = con[:, :, 0]
plot_connectivity_circle(conmat,
label_names,
n_lines=300,
node_angles=node_angles,
node_colors=node_colors,
title='All-to-All Connectivity left-Auditory '
'Condition (PLI)')
# Uncomment the following line to save the figure
'''
import matplotlib.pyplot as plt
plt.savefig('circle.png', facecolor='black')
'''
def test_plot_connectivity_circle():
"""Test plotting connectivity circle."""
node_order = ['frontalpole-lh', 'parsorbitalis-lh',
'lateralorbitofrontal-lh', 'rostralmiddlefrontal-lh',
'medialorbitofrontal-lh', 'parstriangularis-lh',
'rostralanteriorcingulate-lh', 'temporalpole-lh',
'parsopercularis-lh', 'caudalanteriorcingulate-lh',
'entorhinal-lh', 'superiorfrontal-lh', 'insula-lh',
'caudalmiddlefrontal-lh', 'superiortemporal-lh',
'parahippocampal-lh', 'middletemporal-lh',
'inferiortemporal-lh', 'precentral-lh',
'transversetemporal-lh', 'posteriorcingulate-lh',
'fusiform-lh', 'postcentral-lh', 'bankssts-lh',
'supramarginal-lh', 'isthmuscingulate-lh', 'paracentral-lh',
'lingual-lh', 'precuneus-lh', 'inferiorparietal-lh',
'superiorparietal-lh', 'pericalcarine-lh',
'lateraloccipital-lh', 'cuneus-lh', 'cuneus-rh',
'lateraloccipital-rh', 'pericalcarine-rh',
'superiorparietal-rh', 'inferiorparietal-rh', 'precuneus-rh',
'lingual-rh', 'paracentral-rh', 'isthmuscingulate-rh',
'supramarginal-rh', 'bankssts-rh', 'postcentral-rh',
'fusiform-rh', 'posteriorcingulate-rh',
'transversetemporal-rh', 'precentral-rh',
'inferiortemporal-rh', 'middletemporal-rh',
'parahippocampal-rh', 'superiortemporal-rh',
'caudalmiddlefrontal-rh', 'insula-rh', 'superiorfrontal-rh',
'entorhinal-rh', 'caudalanteriorcingulate-rh',
'parsopercularis-rh', 'temporalpole-rh',
'rostralanteriorcingulate-rh', 'parstriangularis-rh',
'medialorbitofrontal-rh', 'rostralmiddlefrontal-rh',
'lateralorbitofrontal-rh', 'parsorbitalis-rh',
'frontalpole-rh']
label_names = ['bankssts-lh', 'bankssts-rh', 'caudalanteriorcingulate-lh',
'caudalanteriorcingulate-rh', 'caudalmiddlefrontal-lh',
'caudalmiddlefrontal-rh', 'cuneus-lh', 'cuneus-rh',
'entorhinal-lh', 'entorhinal-rh', 'frontalpole-lh',
'frontalpole-rh', 'fusiform-lh', 'fusiform-rh',
'inferiorparietal-lh', 'inferiorparietal-rh',
'inferiortemporal-lh', 'inferiortemporal-rh', 'insula-lh',
'insula-rh', 'isthmuscingulate-lh', 'isthmuscingulate-rh',
'lateraloccipital-lh', 'lateraloccipital-rh',
'lateralorbitofrontal-lh', 'lateralorbitofrontal-rh',
'lingual-lh', 'lingual-rh', 'medialorbitofrontal-lh',
'medialorbitofrontal-rh', 'middletemporal-lh',
'middletemporal-rh', 'paracentral-lh', 'paracentral-rh',
'parahippocampal-lh', 'parahippocampal-rh',
'parsopercularis-lh', 'parsopercularis-rh',
'parsorbitalis-lh', 'parsorbitalis-rh',
'parstriangularis-lh', 'parstriangularis-rh',
'pericalcarine-lh', 'pericalcarine-rh', 'postcentral-lh',
'postcentral-rh', 'posteriorcingulate-lh',
'posteriorcingulate-rh', 'precentral-lh', 'precentral-rh',
'precuneus-lh', 'precuneus-rh',
'rostralanteriorcingulate-lh',
'rostralanteriorcingulate-rh', 'rostralmiddlefrontal-lh',
'rostralmiddlefrontal-rh', 'superiorfrontal-lh',
'superiorfrontal-rh', 'superiorparietal-lh',
'superiorparietal-rh', 'superiortemporal-lh',
'superiortemporal-rh', 'supramarginal-lh',
'supramarginal-rh', 'temporalpole-lh', 'temporalpole-rh',
'transversetemporal-lh', 'transversetemporal-rh']
group_boundaries = [0, len(label_names) / 2]
node_angles = circular_layout(label_names, node_order, start_pos=90,
group_boundaries=group_boundaries)
con = np.random.RandomState(0).randn(68, 68)
plot_connectivity_circle(con, label_names, n_lines=300,
node_angles=node_angles, title='test',
)
pytest.raises(ValueError, circular_layout, label_names, node_order,
group_boundaries=[-1])
pytest.raises(ValueError, circular_layout, label_names, node_order,
group_boundaries=[20, 0])
plt.close('all')
def test_plot_connectivity_circle():
"""Test plotting connectivity circle
"""
node_order = [
"frontalpole-lh",
"parsorbitalis-lh",
"lateralorbitofrontal-lh",
"rostralmiddlefrontal-lh",
"medialorbitofrontal-lh",
"parstriangularis-lh",
"rostralanteriorcingulate-lh",
"temporalpole-lh",
"parsopercularis-lh",
"caudalanteriorcingulate-lh",
"entorhinal-lh",
"superiorfrontal-lh",
"insula-lh",
"caudalmiddlefrontal-lh",
"superiortemporal-lh",
"parahippocampal-lh",
"middletemporal-lh",
"inferiortemporal-lh",
"precentral-lh",
"transversetemporal-lh",
"posteriorcingulate-lh",
"fusiform-lh",
"postcentral-lh",
"bankssts-lh",
"supramarginal-lh",
"isthmuscingulate-lh",
"paracentral-lh",
"lingual-lh",
"precuneus-lh",
"inferiorparietal-lh",
"superiorparietal-lh",
"pericalcarine-lh",
"lateraloccipital-lh",
"cuneus-lh",
"cuneus-rh",
"lateraloccipital-rh",
"pericalcarine-rh",
"superiorparietal-rh",
"inferiorparietal-rh",
"precuneus-rh",
"lingual-rh",
"paracentral-rh",
"isthmuscingulate-rh",
"supramarginal-rh",
"bankssts-rh",
"postcentral-rh",
"fusiform-rh",
"posteriorcingulate-rh",
"transversetemporal-rh",
"precentral-rh",
"inferiortemporal-rh",
"middletemporal-rh",
"parahippocampal-rh",
"superiortemporal-rh",
"caudalmiddlefrontal-rh",
"insula-rh",
"superiorfrontal-rh",
"entorhinal-rh",
"caudalanteriorcingulate-rh",
"parsopercularis-rh",
"temporalpole-rh",
"rostralanteriorcingulate-rh",
"parstriangularis-rh",
"medialorbitofrontal-rh",
"rostralmiddlefrontal-rh",
"lateralorbitofrontal-rh",
"parsorbitalis-rh",
"frontalpole-rh",
]
label_names = [
"bankssts-lh",
"bankssts-rh",
"caudalanteriorcingulate-lh",
"caudalanteriorcingulate-rh",
"caudalmiddlefrontal-lh",
"caudalmiddlefrontal-rh",
"cuneus-lh",
"cuneus-rh",
"entorhinal-lh",
"entorhinal-rh",
"frontalpole-lh",
"frontalpole-rh",
"fusiform-lh",
"fusiform-rh",
"inferiorparietal-lh",
"inferiorparietal-rh",
"inferiortemporal-lh",
"inferiortemporal-rh",
"insula-lh",
"insula-rh",
"isthmuscingulate-lh",
"isthmuscingulate-rh",
"lateraloccipital-lh",
"lateraloccipital-rh",
"lateralorbitofrontal-lh",
"lateralorbitofrontal-rh",
"lingual-lh",
"lingual-rh",
"medialorbitofrontal-lh",
"medialorbitofrontal-rh",
"middletemporal-lh",
"middletemporal-rh",
"paracentral-lh",
"paracentral-rh",
"parahippocampal-lh",
"parahippocampal-rh",
"parsopercularis-lh",
"parsopercularis-rh",
"parsorbitalis-lh",
"parsorbitalis-rh",
"parstriangularis-lh",
"parstriangularis-rh",
"pericalcarine-lh",
"pericalcarine-rh",
"postcentral-lh",
"postcentral-rh",
"posteriorcingulate-lh",
"posteriorcingulate-rh",
"precentral-lh",
"precentral-rh",
"precuneus-lh",
"precuneus-rh",
"rostralanteriorcingulate-lh",
"rostralanteriorcingulate-rh",
"rostralmiddlefrontal-lh",
"rostralmiddlefrontal-rh",
"superiorfrontal-lh",
"superiorfrontal-rh",
"superiorparietal-lh",
"superiorparietal-rh",
"superiortemporal-lh",
"superiortemporal-rh",
"supramarginal-lh",
"supramarginal-rh",
"temporalpole-lh",
"temporalpole-rh",
"transversetemporal-lh",
"transversetemporal-rh",
]
group_boundaries = [0, len(label_names) / 2]
node_angles = circular_layout(label_names, node_order, start_pos=90, group_boundaries=group_boundaries)
con = np.random.randn(68, 68)
plot_connectivity_circle(con, label_names, n_lines=300, node_angles=node_angles, title="test")
plt.close("all")
assert_raises(ValueError, circular_layout, label_names, node_order, group_boundaries=[-1])
assert_raises(ValueError, circular_layout, label_names, node_order, group_boundaries=[20, 0])
rh_labels = [label[:-2] + 'rh' for label in lh_labels
if label != 'Brain-Stem' and label[:-2] + 'rh' in rh_labels]
# Save the plot order
node_order = list()
node_order = lh_labels[::-1] + rh_labels
node_angles = circular_layout(label_names, node_order, start_pos=90,
group_boundaries=[0, len(label_names) // 2])
# Plot the graph using node colors from the FreeSurfer parcellation. We only
# show the 300 strongest connections.
conmat = con[:, :, 0]
fig = plt.figure(num=None, figsize=(8, 8), facecolor='black')
plot_connectivity_circle(conmat, label_names, n_lines=300,
node_angles=node_angles, node_colors=node_colors,
title='All-to-All Connectivity left-Auditory '
'Condition (PLI)', fig=fig, interactive=False)
###############################################################################
# Save the figure (optional)
# --------------------------
#
# By default matplotlib does not save using the facecolor, even though this was
# set when the figure was generated. If not set via savefig, the labels, title,
# and legend will be cut off from the output png file.
# fname_fig = data_path + '/MEG/sample/plot_mixed_connect.png'
# plt.savefig(fname_fig, facecolor='black')
node_colors.append(next(colors))
node_colors.extend(node_colors)
node_angles = circular_layout(
label_names,
node_order,
start_pos=90,
group_boundaries=[0, len(label_names) / 2])
# Difference map
if idx2 == 'diff' or idx2 == 'diff3':
[fig1, _] = plot_connectivity_circle(con_res,
label_names,
n_lines=None,
node_angles=node_angles,
node_colors=node_colors,
colormap='BlueRed1',
vmin=-99,
vmax=99,
title=names[num][num2])
# Heatmaps
else:
[fig1, _] = plot_connectivity_circle(con_res,
label_names,
n_lines=None,
node_angles=node_angles,
node_colors=node_colors,
colormap='afmhot',
vmin=0,
print("E2E prediction results:")
test_metrics_0 = regression_metrics(y_pred_0, y_true_0)
print("class 0: {0}".format(test_metrics_0))
test_metrics_1 = regression_metrics(y_pred_1, y_true_1)
print("class 1: {0}".format(test_metrics_1))
# Saliency map is the gradient of the maximum score value with respect to
# the input image.
model.model.eval()
X = torch.from_numpy(x_test)
X.requires_grad_()
scores = model.model(X)
scores.backward(torch.ones(scores.shape, dtype=torch.float32))
saliency, _ = torch.max(X.grad.data.abs(), dim=1)
saliency = np.mean(saliency.numpy(), axis=0)
hemi_size = len(labels) // 2
node_order = labels[:hemi_size]
node_order.extend(labels[hemi_size:][::-1])
node_angles = circular_layout(labels,
node_order,
start_pos=90,
group_boundaries=[0, hemi_size])
plot_connectivity_circle(saliency,
labels,
n_lines=300,
node_angles=node_angles,
title="Partial derivatives mapped on a circle plot")
plt.show()
def plot_conn_stats(AB_con,
fig,
flatten=True,
errdist_perms=0,
pctl=5,
min_corr_diff=0,
pcorrs=False,
neg_norm=True,
fdr_alpha=0.2,
exclude_conns=True,
savefig=None,
ccstatsmat=None,
inds_cc=None,
vvstatsmat=None,
refresh=False,
nofig=False,
rel=True):
""" generates correlation and ASC stats for a pair of states. """
# generate basic correlation and variance stats
if ccstatsmat is None:
inds_cc = find(
mne.stats.fdr_correction(fa(
AB_con.get_corr_stats(pcorrs=pcorrs, rel=rel)[1]),
alpha=fdr_alpha)[0])
ccstatsmat = -fa(AB_con.get_corr_stats(pcorrs=pcorrs, rel=rel)[0])
vvstatsmat = -AB_con.get_std_stats(pcorrs=pcorrs, rel=rel)
# generate ASC limits
lims = AB_con.get_ASC_lims(pcorrs=pcorrs,
errdist_perms=errdist_perms,
refresh=refresh,
pctl=pctl)
# gen correlation matrices for plotting
Acorrs_mat = np.mean(AB_con.A.get_corrs(pcorrs=pcorrs), 0, keepdims=True)
Acorrs = fa(Acorrs_mat) # flattening
Bcorrs_mat = np.mean(AB_con.B.get_corrs(pcorrs=pcorrs), 0, keepdims=True)
Bcorrs = fa(Bcorrs_mat) # flattening
# min_corr_diff is the minimum change in correlation considered interesting (significant but tiny effects may not be interesting)
if min_corr_diff != 0:
inds_corr_diff = find(abs(Acorrs - Bcorrs) > min_corr_diff)
inds_cc = np.intersect1d(inds_corr_diff, inds_cc)
##################################
# set plot colours and other specs
plot_colors = [(0.2, 0.6, 1), (0.62, 0.82, 0.98), (0.40, 0.95, 0.46),
(0.6, 0.95, 0.6), (0.15, 0.87, 0.87), (0.8, 0.8, 0.8)]
cdict1 = {
'red': ((0.0, 0.0, 0.0), (0.75, 0.5, 0.5), (1.0, 1.0, 1.0)),
'green': ((0.0, 0.0, 0.0), (1.0, 0.0, 0.0)),
'blue': ((0.0, 0.0, 1.0), (0.25, 0.5, 0.5), (1.0, 0, 0))
}
cdict2 = {
'red': ((0.0, 0.0, 0.0), (0.5, 0.0, 0.1), (1.0, 1.0, 1.0)),
'green': ((0.0, 0.0, 0.0), (1.0, 0.0, 0.0)),
'blue': ((0.0, 0.0, 1.0), (0.5, 0.1, 0.0), (1.0, 0.0, 0.0))
}
blue_red1 = LinearSegmentedColormap('BlueRed1', cdict1)
plt.register_cmap(cmap=blue_red1)
cmap2 = matplotlib.colors.ListedColormap(name='Test', colors=plot_colors)
plt.register_cmap(cmap=cmap2)
fontsize = 9
current_palette = [
(0.2980392156862745, 0.4470588235294118, 0.6901960784313725),
(0.3333333333333333, 0.6588235294117647, 0.40784313725490196),
(0.7686274509803922, 0.3058823529411765, 0.3215686274509804),
(0.5058823529411764, 0.4470588235294118, 0.6980392156862745),
(0.8, 0.7254901960784313, 0.4549019607843137),
(0.39215686274509803, 0.7098039215686275, 0.803921568627451)
]
sb_cols = current_palette + current_palette + current_palette
# colours for variance stats
vcols = []
# scaling stats for plotting colours for variance change
vv_norm = vvstatsmat / 6
vv_norm[np.isnan(vv_norm)] = 0
n_nodes = AB_con.A.get_covs().shape[1]
for a in np.arange(n_nodes):
vcols.append(blue_red1((vv_norm[a] + 1) / 2))
vmax = 3
vmin = -3
# node info
node_angles = np.linspace(0, 2 * np.pi, n_nodes, endpoint=False)
height = np.ones(n_nodes) * 4
dist_mat = node_angles[None, :] - node_angles[:, None]
dist_mat[np.diag_indices(n_nodes)] = 1e9
node_width = np.min(np.abs(dist_mat))
node_edgecolor = 'black'
group_cols = []
# colours for ROIs
ROI_info = AB_con.A.ROI_info
for a in ROI_info['ROI_RSNs']:
val = 1 - 0.35 * a / max(ROI_info['ROI_RSNs'])
group_cols.append((val * 0.8, val * 0.9, val))
plots = ['uncorrelated', 'common', 'additive', 'other']
titles = {
'uncorrelated': "Addition of uncorrelated signal",
'common': "Addition of common signal",
'additive': "Mixed additive signals",
'other': "Changes not explained \n by additive signal changes"
}
#################################
# plot data
indices = np.triu_indices(n_nodes, 1)
notin = inds_cc.copy()
inds_plots = {}
for plot in plots[:3]:
if errdist_perms > 0:
inds_plots[plot] = np.intersect1d(inds_cc,
find(fa(lims[plot]['pctls'])))
notin = np.setdiff1d(notin, find(fa(lims[plot]['pctls'])))
minstr = 'min_pctls'
maxstr = 'max_pctls'
else:
inds_plots[plot] = np.intersect1d(
inds_cc, find(fa(lims[plot]['pctls_noerr'])))
notin = np.setdiff1d(notin, find(fa(lims[plot]['pctls_noerr'])))
minstr = 'min'
maxstr = 'max'
inds_plots['other'] = notin
if exclude_conns:
inds_plots['common'] = np.setdiff1d(inds_plots['common'],
inds_plots['uncorrelated'])
inds_plots['additive'] = np.setdiff1d(inds_plots['additive'],
inds_plots['common'])
inds_plots['additive'] = np.setdiff1d(inds_plots['additive'],
inds_plots['uncorrelated'])
plotccstats = ccstatsmat.astype(float)
# flip color of changes to negative corrs (neg_norm option)
if neg_norm == True:
plotccstats = plotccstats * np.sign(Acorrs)
cnt = -1
#################################
# produce the four plots for the four ASC classes
if fig != None:
fig.clf()
for plot in plots:
cnt += 1
################################################
# mne plot function
# TODO: test for mne / nofig
pp = plot_connectivity_circle(
plotccstats.flatten()[inds_plots[plot]],
ROI_info['ROI_names'][0:n_nodes],
(indices[0][inds_plots[plot]], indices[1][inds_plots[plot]]),
fig=fig,
colormap='BlueRed1',
vmin=vmin,
vmax=vmax,
node_colors=vcols,
subplot=241 + cnt,
title=titles[plot],
interactive=True,
fontsize_names=fontsize,
facecolor='w',
colorbar=False,
node_edgecolor=node_edgecolor,
textcolor='black',
padding=3,
node_linewidth=0.5)
# titles
ax = plt.gca()
ax.set_title(titles[plot], color='black')
# color node faces
bars = pp[1].bar(node_angles, height*2.2, width=node_width, bottom=10.4, \
edgecolor='0.9', lw=2, facecolor='.9', \
align='center',linewidth=1)
for bar, color in zip(bars, group_cols):
bar.set_facecolor(color)
bar.set_edgecolor(color)
# plot correlation info below circle plots
if plot == 'other':
plotrange = 'additive'
else:
plotrange = plot
# sorting plotting only those indices requested
sort_array = np.zeros((len(inds_plots[plot]), ), dtype=('f4,f4'))
sort_array['f0'] = fa(lims[plotrange][minstr])[0,
inds_plots[plot]] #
sort_array['f1'] = fa(lims[plotrange][maxstr])[0,
inds_plots[plot]] #
ii = np.argsort(sort_array, order=['f0', 'f1'])
# plot conn info
if len(ii) > 0:
# width of nodes
width = np.max((20, len(ii) + 10))
# ii_ext
ii_ext = np.r_[ii[0], ii, ii[-1]]
# fbwx: midpoints for under plots
fbwx = np.arange(len(ii_ext)) + (width - len(ii_ext)) / 2.
fbwx[
0] = fbwx[0] + 0.5 #=np.r_[fbwx[0]-0.5, fbwx,fbwx[-1]+0.5]
fbwx[-1] = fbwx[-1] - 0.5
# axis settings
ax = plt.subplot(245 + cnt, axisbg='white')
ax.set_ylim([-1., 1])
ax.set_yticks([-1, 0, 1])
ax.set_yticks([-0.75, -.25, 0, 0.25, .5, .75, 1], minor=True)
ax.yaxis.grid(color=[0.7, .95, .95],
linestyle='-',
linewidth=.5,
which='minor')
ax.yaxis.grid(color=[0.65, .85, .85],
linestyle='-',
linewidth=2,
which='major')
# first plot bands for ASC / uncorr / common (fill between)
if len(fbwx) == 1:
# if only one element
plt.fill_between(np.r_[fbwx - 0.5, fbwx + 0.5],
np.r_[fa(lims['additive'][minstr])[
0, inds_plots[plot]][ii_ext],
fa(lims['additive'][minstr])[
0, inds_plots[plot]][ii_ext]],
np.r_[fa(lims['additive'][maxstr])[
0, inds_plots[plot]][ii_ext],
fa(lims['additive'][maxstr])[
0, inds_plots[plot]][ii_ext]],
color='Grey',
alpha=0.4)
plt.fill_between(np.r_[fbwx - 0.5, fbwx + 0.5],
np.r_[fa(lims['common'][minstr])[
0, inds_plots[plot]][ii_ext],
fa(lims['common'][minstr])[
0, inds_plots[plot]][ii_ext]],
np.r_[fa(lims['common'][maxstr])[
0, inds_plots[plot]][ii_ext],
fa(lims['common'][maxstr])[
0, inds_plots[plot]][ii_ext]],
color='Blue',
alpha=0.4)
plt.fill_between(np.r_[fbwx - 0.5, fbwx + 0.5],
np.r_[fa(lims['uncorrelated'][minstr])[
0, inds_plots[plot]][ii_ext],
fa(lims['uncorrelated'][minstr])[
0, inds_plots[plot]][ii_ext]],
np.r_[fa(lims['uncorrelated'][maxstr])[
0, inds_plots[plot]][ii_ext],
fa(lims['uncorrelated'][maxstr])[
0, inds_plots[plot]][ii_ext]],
color='Green',
alpha=0.6)
else:
# if multple elements
plt.fill_between(
fbwx,
fa(lims['additive'][minstr])[0,
inds_plots[plot]][ii_ext],
fa(lims['additive'][maxstr])[0,
inds_plots[plot]][ii_ext],
color=[0.67, 0.76, 0.85])
plt.fill_between(
fbwx,
fa(lims['common'][minstr])[0,
inds_plots[plot]][ii_ext],
fa(lims['common'][maxstr])[0,
inds_plots[plot]][ii_ext],
color='Blue',
alpha=0.4)
plt.fill_between(fbwx,
fa(lims['uncorrelated'][minstr])[
0, inds_plots[plot]][ii_ext],
fa(lims['uncorrelated'][maxstr])[
0, inds_plots[plot]][ii_ext],
color='Green',
alpha=0.6)
if neg_norm == True:
iipospos = np.in1d(
ii,
find(
abs(Acorrs[0, inds_plots[plot]]) > abs(Bcorrs[
0, inds_plots[plot]])))
iinegpos = np.in1d(
ii,
find(
abs(Acorrs[0, inds_plots[plot]]) < abs(Bcorrs[
0, inds_plots[plot]])))
else:
iipospos = np.in1d(
ii,
find(Acorrs[0, inds_plots[plot]] > Bcorrs[
0, inds_plots[plot]]))
iinegpos = np.in1d(
ii,
find(Acorrs[0, inds_plots[plot]] < Bcorrs[
0, inds_plots[plot]]))
iipos = ii[iipospos]
iineg = ii[iinegpos]
xes = np.arange(len(ii)) + (width - len(ii)) / 2.
# now plot correlation in A and B conditions
plt.plot(np.array([xes, xes])[:, find(iipospos)], [
Acorrs[0, inds_plots[plot][iipos]],
Bcorrs[0, inds_plots[plot][iipos]]
],
color=[0, 0, 1],
alpha=1,
linewidth=1.5,
zorder=1)
plt.plot(np.array([xes, xes])[:, find(iinegpos)], [
Acorrs[0, inds_plots[plot][iineg]],
Bcorrs[0, inds_plots[plot][iineg]]
],
color=[1, 0, 0],
alpha=1,
linewidth=1.5,
zorder=1)
plt.fill_between(
fbwx,
fa(lims['uncorrelated'][minstr])[0,
inds_plots[plot]][ii_ext],
fa(lims['uncorrelated'][maxstr])[0,
inds_plots[plot]][ii_ext],
color='Green',
alpha=0.6)
line3 = plt.Rectangle((0, 0), 0, 0, color=current_palette[0])
ax.add_patch(line3)
ax.set_xticks([])
# plot points
line2 = plt.scatter((xes)[find(iipospos)],
Bcorrs[0, inds_plots[plot][iipos]].T,
color='blue',
zorder=2)
line2 = plt.scatter((xes)[find(iinegpos)],
Bcorrs[0, inds_plots[plot][iineg]].T,
color='red',
zorder=2)
line2 = plt.scatter((xes)[find(iipospos)],
Acorrs[0, inds_plots[plot][iipos]].T,
color='white',
zorder=2)
line2 = plt.scatter((xes)[find(iinegpos)],
Acorrs[0, inds_plots[plot][iineg]].T,
color='white',
zorder=2)
# plot line between, colouring line two according to pos or neg change
cmap = ListedColormap([(0.2980392156862745, 0.4470588235294118,
0.6901960784313725),
(0.3333333333333333, 0.6588235294117647,
0.40784313725490196),
(0.7686274509803922, 0.3058823529411765,
0.3215686274509804)])
norm = BoundaryNorm([-2, 0, 1, 2], cmap.N)
z = np.zeros(xes.shape[0] + 1, )
# plot network membership above
colorline(fbwx[:-1],
z + 1.05,
ROI_info['ROI_RSNs'][indices[0][np.r_[
inds_plots[plot], inds_plots[plot][-1]]]] - 1.5,
cmap=cmap,
norm=norm,
linewidth=5)
colorline(fbwx[:-1],
z + 1.1,
ROI_info['ROI_RSNs'][indices[1][np.r_[
inds_plots[plot], inds_plots[plot][-1]]]] - 1.5,
cmap=cmap,
norm=norm,
linewidth=5)
plt.show()
if savefig != None:
if nofig == 23:
pp = PdfPages(fname)
fig.tight_layout(h_pad=1, pad=4)
pp.savefig(fig=fig)
pp.close()
else:
fig.savefig(savefig)
# add stats to AB_con struct
AB_con.lims['covs']['inds_plots'] = inds_plots
AB_con.lims['covs']['cc_stats'] = ccstatsmat
AB_con.lims['covs']['vv_stats'] = vvstatsmat
return (AB_con, inds_plots)
def plot_tab_circular_connectivity(list_list_conmat,
all_elec_labels,
plot_filename,
coh_low_thresh=0.0,
coh_high_thresh=1.0,
color_bar='gist_rainbow',
column_labels=[],
row_labels=[]):
"""Plot tab circular conectivity."""
nb_lines = len(list_list_conmat)
print(nb_lines)
print(len(list_list_conmat[0]))
if len(list_list_conmat) != 1:
for i, j in combinations(list(range(nb_lines)), 2):
assert len(list_list_conmat[i]) == len(
list_list_conmat[j]), ("Error, not all the same length {} != "
"{}".format(len(list_list_conmat[i]),
len(list_list_conmat[j])))
nb_cols = len(list_list_conmat[0])
# for i in
# print list_list_conmat[0][0].shape
# Angles
bounds = [0, len(all_elec_labels) / 2]
all_node_angles = circular_layout(all_elec_labels,
node_order=all_elec_labels,
start_pos=90,
group_boundaries=bounds)
# print all_node_angles
fig, axes = plt.subplots(nrows=nb_lines,
ncols=nb_cols,
figsize=(4 * nb_cols, 4 * nb_lines),
facecolor='black')
# fig = plt.figure(num=None, figsize=(4*nb_cols, 4*nb_lines),
# facecolor='black')
if len(column_labels) == 0:
column_labels = ['Column {}'.format(col) for col in range(nb_cols)]
if len(row_labels) == 0:
row_labels = ['Line {}'.format(row) for row in range(nb_lines)]
assert len(column_labels) == nb_cols, (
"Error, specifying invalid number of column labels")
assert len(row_labels) == nb_lines, (
"Error, specifying invalid number of line labels")
for index_sess, list_conmat in enumerate(list_list_conmat):
print(len(list_conmat))
for index_win, np_all_mean_con_mats in enumerate(list_conmat):
print(np_all_mean_con_mats.shape)
kw = dict(textcolor="black",
facecolor="white",
n_lines=None,
node_angles=all_node_angles,
fontsize_names=15,
show=False,
colormap=color_bar,
vmin=coh_low_thresh,
vmax=coh_high_thresh,
fig=fig,
subplot=(nb_lines, nb_cols,
1 + index_win + nb_cols * index_sess))
if index_win == len(list_conmat) - 1:
fig, ax = plot_connectivity_circle(np_all_mean_con_mats,
all_elec_labels,
colorbar_size=0.5,
**kw)
# (nb_lines,nb_cols,1+index_win+nb_cols*index_sess))
else:
fig, ax = plot_connectivity_circle(np_all_mean_con_mats,
all_elec_labels,
colorbar=False,
**kw)
if index_win == 0:
ax.set_ylabel(row_labels[index_sess],
rotation=0,
size='large',
fontsize=25)
if index_sess == 0:
ax.set_title(column_labels[index_win],
fontdict={'fontsize': 25})
# saving
print(plot_filename)
fig.savefig(plot_filename, facecolor='white')
plt.close(fig)
# fig1.close()
del fig
with open(yaml_fname, 'r') as f:
xlabels = yaml.safe_load(f)
# the yaml file has been hand curated to follow the same order as label_names
# if not the node order has to be changed appropriately
node_order = list()
node_order.extend(label_names)
group_bound = [len(list(key.values())[0]) for key in xlabels]
group_bound = [0] + group_bound
group_boundaries = [sum(group_bound[:i+1]) for i in range(len(group_bound))]
group_boundaries.pop()
rsn_colors = ['m', 'b', 'y', 'c', 'r', 'g', 'w']
group_bound.pop(0)
label_colors = []
for ind, rep in enumerate(group_bound):
label_colors += [rsn_colors[ind]] * rep
assert len(label_colors) == len(node_order), 'Number of colours do not match'
from mne.viz.circle import circular_layout
node_angles = circular_layout(label_names, label_names, start_pos=90,
group_boundaries=group_boundaries)
# Plot the graph using node colors from the FreeSurfer parcellation.
plot_connectivity_circle(con_res['wpli'], label_names, n_lines=300,
node_angles=node_angles, node_colors=label_colors,
title='Connectivity between standard RSNs')
# plt.savefig('circle.png', facecolor='black')
def main():
parser = buildArgsParser()
args = parser.parse_args()
if not os.path.exists(args.matrix):
parser.error("{0} is not a valid file path.".format(args.matrix))
if not os.path.splitext(args.matrix)[1] == ".npy":
parser.error("Connectivity matrix must be given in .npy format.")
if not os.path.exists(args.row_map):
parser.error("{0} is not a valid file path.".format(args.row_map))
if os.path.splitext(args.row_map)[1] != ".pkl":
parser.error("Name mapping must be given in a .pkl file.")
if args.save and os.path.exists(args.save) and not args.force:
parser.error("Output image: {0} already exists.\n".format(args.save) +
"Use -f to force overwriting.")
con_mat = np.load(args.matrix)
with open(args.row_map) as f:
row_name_map = pickle.load(f)
lh_tags = ['_lh_', 'Left']
rh_tags = ['_rh_', 'Right']
if args.clean_lbl:
label_names = [row_name_map[k]['lut_name'] for k in sorted(row_name_map)]
lh_tags = ['LH']
rh_tags = ['RH']
else:
label_names = [row_name_map[k]['free_name'] for k in sorted(row_name_map)]
lh_tags.append('-lh-')
rh_tags.append('-rh-')
lh_labels = [name for name in label_names if any(tag in name for tag in lh_tags)]
rh_labels = [name for name in label_names if any(tag in name for tag in rh_tags)]
# Validate if all labels were found
uncut_labels = set(label_names) - set(lh_labels) - set(rh_labels)
if len(uncut_labels) > 0:
raise ValueError("Some labels were not filtered as Left or Right.")
if args.sort_y:
# TODO choose color
# label_colors = [label.color for label in labels]
label_ypos = []
for name in lh_labels:
label_ypos.append(find_mean_y_pos(row_name_map, name))
lh_labels = [label for (ypos, label) in sorted(zip(label_ypos, lh_labels))]
rh_labels = [label for (ypos, label) in sorted(zip(label_ypos, rh_labels))]
node_order = list()
node_order.extend(lh_labels[::-1]) # reverse the order
node_order.extend(rh_labels)
node_angles = circular_layout(label_names, node_order, start_pos=90,
group_boundaries=[0, len(label_names) / 2])
fig, axes = plot_connectivity_circle(con_mat, label_names, linewidth=1.5,
interactive=True, vmin=0, vmax=1,
node_angles=node_angles,
title='All-to-all Connectivity')
# plot_connectivity_circle(
# node_colors=label_colors,
# fontsize_colorbar=6,
plt.show(block=True)
if args.save:
fig.savefig(args.save, facecolor='black')
delta2 = range2[1] - range2[0]
return (delta2 * (x - range1[0]) / delta1) + range2[0]
# title
tlt = 'Phase-Coherence Connectivity among DMN regions and V1 \n for \n State %d (%s)' % (
k, freq)
fig = plt.figure(num=None, figsize=(8, 8))
plot_connectivity_circle(con,
node_names,
indices=indices,
node_angles=node_angles,
facecolor='white',
textcolor='black',
node_colors=node_colors,
linewidth=3,
node_edgecolor='black',
colormap='RdBu_r',
fontsize_names=12,
fontsize_colorbar=12,
vmin=vmin,
vmax=vmax,
colorbar_pos=(-0.7, 0.25),
title=tlt,
fig=fig)
# save plot
fig.savefig('fig/CirclePlt_' + fn_keys + '_Tvalue.png',
dpi=300,
transparent=True)
# Get the y-location of the label
label_ypos = list()
for name in lh_labels:
idx = label_names.index(name)
ypos = np.mean(labels[idx].pos[:, 1])
label_ypos.append(ypos)
# Reorder the labels based on their location
lh_labels = [label for (ypos, label) in sorted(zip(label_ypos, lh_labels))]
# For the right hemi
rh_labels = [label[:-2] + 'rh' for label in lh_labels]
# 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)
node_angles = circular_layout(label_names, node_order, start_pos=90)
# Plot the graph using node colors from the FreeSurfer parcellation. We only
# show the 300 strongest connections.
plot_connectivity_circle(con, label_names, n_lines=300, node_angles=node_angles,
node_colors=label_colors,
title='All-to-All Connectivity left-Auditory '
'Condition')
import matplotlib.pyplot as plt
plt.savefig('circle.png', facecolor='black')
plt.show()
@author: bejar
"""
from mne.io import read_raw_bti
from mne.viz import circular_layout, plot_connectivity_circle
import numpy as np
import matplotlib.pyplot as plt
def plotOneSignal(signal):
fig = plt.figure()
minaxis=min(signal)
maxaxis=max(signal)
num=len(signal)
sp1=fig.add_subplot(111)
# sp1.axis([0,num,minaxis,maxaxis])
t = arange(0.0, num, 1)
sp1.plot(t,signal)
plt.show()
a=read_raw_bti('/home/bejar/MEG/ESQ21com10/ESQ21com10/MEG@-EKG/05@-25@-12@_10:00/1/c,rfhp1.0Hz')
cnames= a.info['ch_names'][0:148]
con=np.array([0.2,0.3,0.4,0.8,0.9])
lind=(np.array([12,79,123,104,97,61]),np.array([88,36,74,27,32,54]))
plot_connectivity_circle(con, cnames, indices=lind,title='Connections',n_lines=6,
linewidth=3,colormap='hot',vmin=0,vmax=1)
plt.savefig('circle.png', facecolor='black')
plt.show()
