def plot_all(conn_matrix, conn_model, atlas_select, dir_path, ID, network, label_names, mask, coords, edge_threshold, plot_switch):
from nilearn import plotting as niplot
pruning=True
dpi_resolution=1000
if plot_switch == True:
import pkg_resources
import networkx as nx
from pynets import plotting
import matplotlib.pyplot as plt
from pynets.netstats import most_important
G_pre=nx.from_numpy_matrix(conn_matrix)
if pruning == True:
[G, pruned_nodes, pruned_edges] = most_important(G_pre)
else:
G = G_pre
conn_matrix = nx.to_numpy_array(G)
pruned_nodes.sort(reverse = True)
for j in pruned_nodes:
del label_names[label_names.index(label_names[j])]
del coords[coords.index(coords[j])]
pruned_edges.sort(reverse = True)
for j in pruned_edges:
del label_names[label_names.index(label_names[j])]
del coords[coords.index(coords[j])]
##Plot connectogram
if len(conn_matrix) > 20:
try:
plotting.plot_connectogram(conn_matrix, conn_model, atlas_select, dir_path, ID, network, label_names)
except RuntimeError:
print('\n\n\nError: Connectogram plotting failed!')
else:
print('Error: Cannot plot connectogram for graphs smaller than 20 x 20!')
##Plot adj. matrix based on determined inputs
plotting.plot_conn_mat(conn_matrix, conn_model, atlas_select, dir_path, ID, network, label_names, mask)
##Plot connectome
if mask != None:
if network != 'None':
out_path_fig=dir_path + '/' + ID + '_' + atlas_select + '_' + str(conn_model) + '_' + str(os.path.basename(mask).split('.')[0]) + '_' + str(network) + '_connectome_viz.png'
else:
out_path_fig=dir_path + '/' + ID + '_' + atlas_select + '_' + str(conn_model) + '_' + str(os.path.basename(mask).split('.')[0]) + '_connectome_viz.png'
else:
if network != 'None':
out_path_fig=dir_path + '/' + ID + '_' + atlas_select + '_' + str(conn_model) + '_' + str(network) + '_connectome_viz.png'
else:
out_path_fig=dir_path + '/' + ID + '_' + atlas_select + '_' + str(conn_model) + '_connectome_viz.png'
#niplot.plot_connectome(conn_matrix, coords, edge_threshold=edge_threshold, node_size=20, colorbar=True, output_file=out_path_fig)
ch2better_loc = pkg_resources.resource_filename("pynets", "templates/ch2better.nii.gz")
connectome = niplot.plot_connectome(np.zeros(shape=(1,1)), [(0,0,0)], black_bg=True, node_size=0.0001)
connectome.add_overlay(ch2better_loc, alpha=0.4, cmap=plt.cm.gray)
[z_min, z_max] = -np.abs(conn_matrix).max(), np.abs(conn_matrix).max()
connectome.add_graph(conn_matrix, coords, edge_threshold = edge_threshold, edge_cmap = 'Blues', edge_vmax=z_max, edge_vmin=z_min, node_size=4)
connectome.savefig(out_path_fig, dpi=dpi_resolution)
else:
pass
return
def test_most_important():
base_dir = str(Path(__file__).parent/"examples")
in_mat = np.load(base_dir + '/997/997_Default_est_cov_0.1_4.npy')
G = nx.from_numpy_array(in_mat)
start_time = time.time()
[Gt, pruned_nodes] = netstats.most_important(G)
print("%s%s%s" % ('thresh_and_fit (Functional, proportional thresholding) --> finished: ', str(np.round(time.time() - start_time, 1)), 's'))
assert Gt is not None
assert pruned_nodes is not None
def plot_all(conn_matrix, conn_model, atlas_select, dir_path, ID, network,
label_names, mask, coords, thr, node_size, edge_threshold, smooth,
prune, uatlas_select):
import matplotlib
matplotlib.use('agg')
from matplotlib import pyplot as plt
from nilearn import plotting as niplot
import pkg_resources
import networkx as nx
from pynets import plotting, thresholding
from pynets.netstats import most_important, prune_disconnected
try:
import cPickle as pickle
except ImportError:
import _pickle as pickle
coords = list(coords)
label_names = list(label_names)
dpi_resolution = 500
if '\'b' in atlas_select:
atlas_select = atlas_select.decode('utf-8')
if (prune == 1 or prune == 2) and len(coords) == conn_matrix.shape[0]:
G_pre = nx.from_numpy_matrix(conn_matrix)
if prune == 1:
[G, pruned_nodes] = prune_disconnected(G_pre)
elif prune == 2:
[G, pruned_nodes] = most_important(G_pre)
else:
G = G_pre
pruned_nodes = []
pruned_nodes.sort(reverse=True)
print('(Display)')
coords_pre = list(coords)
label_names_pre = list(label_names)
if len(pruned_nodes) > 0:
for j in pruned_nodes:
label_names_pre.pop(j)
coords_pre.pop(j)
conn_matrix = nx.to_numpy_array(G)
label_names = label_names_pre
coords = coords_pre
else:
print('No nodes to prune for plot...')
coords = list(tuple(x) for x in coords)
# Plot connectogram
if len(conn_matrix) > 20:
try:
plotting.plot_connectogram(conn_matrix, conn_model, atlas_select,
dir_path, ID, network, label_names)
except:
print('\n\n\nWarning: Connectogram plotting failed!')
else:
print(
'Warning: Cannot plot connectogram for graphs smaller than 20 x 20!'
)
# Plot adj. matrix based on determined inputs
if not node_size or node_size == 'None':
node_size = 'parc'
plotting.plot_conn_mat_func(conn_matrix, conn_model, atlas_select,
dir_path, ID, network, label_names, mask, thr,
node_size, smooth)
# Plot connectome
if mask:
out_path_fig = "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s" % (
dir_path, '/', ID, '_', str(atlas_select), '_', str(conn_model),
'_', str(os.path.basename(mask).split('.')[0]), "%s" %
("%s%s%s" % ('_', network, '_') if network else "_"), str(thr),
'_', str(node_size), '%s' %
("mm_" if node_size != 'parc' else "_"), "%s" %
("%s%s" % (smooth, 'fwhm_') if float(smooth) > 0 else 'nosm_'),
'func_glass_viz.png')
# Save coords to pickle
coord_path = "%s%s%s%s" % (dir_path, '/coords_',
os.path.basename(mask).split('.')[0],
'_plotting.pkl')
with open(coord_path, 'wb') as f:
pickle.dump(coords, f, protocol=2)
# Save labels to pickle
labels_path = "%s%s%s%s" % (dir_path, '/labelnames_',
os.path.basename(mask).split('.')[0],
'_plotting.pkl')
with open(labels_path, 'wb') as f:
pickle.dump(label_names, f, protocol=2)
else:
out_path_fig = "%s%s%s%s%s%s%s%s%s%s%s%s%s%s" % (
dir_path, '/', ID, '_', str(atlas_select), '_', str(conn_model),
"%s" % ("%s%s%s" % ('_', network, '_') if network else "_"),
str(thr), '_', str(node_size), '%s' %
("mm_" if node_size != 'parc' else "_"), "%s" %
("%s%s" % (smooth, 'fwhm_') if float(smooth) > 0 else 'nosm_'),
'func_glass_viz.png')
# Save coords to pickle
coord_path = "%s%s" % (dir_path, '/coords_plotting.pkl')
with open(coord_path, 'wb') as f:
pickle.dump(coords, f, protocol=2)
# Save labels to pickle
labels_path = "%s%s" % (dir_path, '/labelnames_plotting.pkl')
with open(labels_path, 'wb') as f:
pickle.dump(label_names, f, protocol=2)
ch2better_loc = pkg_resources.resource_filename(
"pynets", "templates/ch2better.nii.gz")
connectome = niplot.plot_connectome(np.zeros(shape=(1, 1)), [(0, 0, 0)],
node_size=0.0001,
black_bg=True)
connectome.add_overlay(ch2better_loc, alpha=0.35, cmap=plt.cm.gray)
conn_matrix = np.array(np.array(thresholding.autofix(conn_matrix)))
[z_min, z_max] = -np.abs(conn_matrix).max(), np.abs(conn_matrix).max()
if node_size == 'parc':
node_size_plot = int(2)
if uatlas_select:
connectome.add_contours(uatlas_select,
filled=False,
alpha=0.3,
colors='black')
else:
node_size_plot = int(node_size)
if len(coords) != conn_matrix.shape[0]:
raise RuntimeWarning(
'WARNING: Number of coordinates does not match conn_matrix dimensions. If you are using disparity filtering, try relaxing the α threshold.'
)
else:
connectome.add_graph(conn_matrix,
coords,
edge_threshold=edge_threshold,
edge_cmap='Blues',
edge_vmax=float(z_max),
edge_vmin=float(z_min),
node_size=node_size_plot,
node_color='auto')
connectome.savefig(out_path_fig, dpi=dpi_resolution)
return
def plot_connectogram(conn_matrix, conn_model, atlas_select, dir_path, ID,
network, label_names):
import json
from pathlib import Path
from networkx.readwrite import json_graph
from pynets.thresholding import normalize
from pynets.netstats import most_important
from scipy.cluster.hierarchy import linkage, fcluster
from nipype.utils.filemanip import save_json
# Advanced Settings
comm = 'nodes'
pruned = False
#color_scheme = 'interpolateCool'
#color_scheme = 'interpolateGnBu'
#color_scheme = 'interpolateOrRd'
#color_scheme = 'interpolatePuRd'
#color_scheme = 'interpolateYlOrRd'
#color_scheme = 'interpolateReds'
#color_scheme = 'interpolateGreens'
color_scheme = 'interpolateBlues'
# Advanced Settings
conn_matrix = normalize(conn_matrix)
G = nx.from_numpy_matrix(conn_matrix)
if pruned is True:
[G, pruned_nodes] = most_important(G)
conn_matrix = nx.to_numpy_array(G)
pruned_nodes.sort(reverse=True)
for j in pruned_nodes:
del label_names[label_names.index(label_names[j])]
def doClust(X, clust_levels):
# get the linkage diagram
Z = linkage(X, 'ward')
# choose # cluster levels
cluster_levels = range(1, int(clust_levels))
# init array to store labels for each level
clust_levels_tmp = int(clust_levels) - 1
label_arr = np.zeros((int(clust_levels_tmp), int(X.shape[0])))
# iterate thru levels
for c in cluster_levels:
fl = fcluster(Z, c, criterion='maxclust')
#print(fl)
label_arr[c - 1, :] = fl
return label_arr, clust_levels_tmp
if comm == 'nodes' and len(conn_matrix) > 40:
from pynets.netstats import modularity_louvain_und_sign
gamma = nx.density(nx.from_numpy_array(conn_matrix))
try:
[node_comm_aff_mat,
q] = modularity_louvain_und_sign(conn_matrix, gamma=float(gamma))
print("%s%s%s%s%s" %
('Found ', str(len(np.unique(node_comm_aff_mat))),
' communities with γ=', str(gamma), '...'))
except:
print(
'WARNING: Louvain community detection failed. Proceeding with single community affiliation vector...'
)
node_comm_aff_mat = np.ones(conn_matrix.shape[0]).astype('int')
clust_levels = len(node_comm_aff_mat)
clust_levels_tmp = int(clust_levels) - 1
mask_mat = np.squeeze(np.array([node_comm_aff_mat == 0]).astype('int'))
label_arr = node_comm_aff_mat * np.expand_dims(
np.arange(1, clust_levels + 1), axis=1) + mask_mat
elif comm == 'links' and len(conn_matrix) > 40:
from pynets.netstats import link_communities
# Plot link communities
link_comm_aff_mat = link_communities(conn_matrix,
type_clustering='single')
print("%s%s%s" %
('Found ', str(len(link_comm_aff_mat)), ' communities...'))
clust_levels = len(link_comm_aff_mat)
clust_levels_tmp = int(clust_levels) - 1
mask_mat = np.squeeze(np.array([link_comm_aff_mat == 0]).astype('int'))
label_arr = link_comm_aff_mat * np.expand_dims(
np.arange(1, clust_levels + 1), axis=1) + mask_mat
elif len(conn_matrix) > 20:
print(
'Graph too small for reliable plotting of communities. Plotting by fcluster instead...'
)
if len(conn_matrix) >= 250:
clust_levels = 7
elif len(conn_matrix) >= 200:
clust_levels = 6
elif len(conn_matrix) >= 150:
clust_levels = 5
elif len(conn_matrix) >= 100:
clust_levels = 4
elif len(conn_matrix) >= 50:
clust_levels = 3
else:
clust_levels = 2
[label_arr, clust_levels_tmp] = doClust(conn_matrix, clust_levels)
def get_node_label(node_idx, labels, clust_levels_tmp):
from collections import OrderedDict
def write_roman(num):
roman = OrderedDict()
roman[1000] = "M"
roman[900] = "CM"
roman[500] = "D"
roman[400] = "CD"
roman[100] = "C"
roman[90] = "XC"
roman[50] = "L"
roman[40] = "XL"
roman[10] = "X"
roman[9] = "IX"
roman[5] = "V"
roman[4] = "IV"
roman[1] = "I"
def roman_num(num):
for r in roman.keys():
x, y = divmod(num, r)
yield roman[r] * x
num -= (r * x)
if num > 0:
roman_num(num)
else:
break
return "".join([a for a in roman_num(num)])
rn_list = []
node_idx = node_idx - 1
node_labels = labels[:, node_idx]
for k in [int(l) for i, l in enumerate(node_labels)]:
rn_list.append(json.dumps(write_roman(k)))
abet = rn_list
node_lab_alph = ".".join([
"{}{}".format(abet[i], int(l)) for i, l in enumerate(node_labels)
]) + ".{}".format(label_names[node_idx])
return node_lab_alph
output = []
adj_dict = {}
for i in list(G.adjacency()):
source = list(i)[0]
target = list(list(i)[1])
adj_dict[source] = target
for node_idx, connections in adj_dict.items():
weight_vec = []
for i in connections:
wei = G.get_edge_data(node_idx, int(i))['weight']
weight_vec.append(wei)
entry = {}
nodes_label = get_node_label(node_idx, label_arr, clust_levels_tmp)
entry["name"] = nodes_label
entry["size"] = len(connections)
entry["imports"] = [
get_node_label(int(d) - 1, label_arr, clust_levels_tmp)
for d in connections
]
entry["weights"] = weight_vec
output.append(entry)
if network:
json_file_name = "%s%s%s%s%s%s" % (str(ID), '_', network,
'_connectogram_', conn_model,
'_network.json')
json_fdg_file_name = "%s%s%s%s%s%s" % (str(ID), '_', network, '_fdg_',
conn_model, '_network.json')
connectogram_plot = "%s%s%s" % (dir_path, '/', json_file_name)
fdg_js_sub = "%s%s%s%s%s%s%s%s" % (dir_path, '/', str(ID), '_',
network, '_fdg_', conn_model,
'_network.js')
fdg_js_sub_name = "%s%s%s%s%s%s" % (str(ID), '_', network, '_fdg_',
conn_model, '_network.js')
connectogram_js_sub = "%s%s%s%s%s%s%s%s" % (dir_path, '/', str(
ID), '_', network, '_connectogram_', conn_model, '_network.js')
connectogram_js_name = "%s%s%s%s%s%s" % (
str(ID), '_', network, '_connectogram_', conn_model, '_network.js')
else:
json_file_name = "%s%s%s%s" % (str(ID), '_connectogram_', conn_model,
'.json')
json_fdg_file_name = "%s%s%s%s" % (str(ID), '_fdg_', conn_model,
'.json')
connectogram_plot = "%s%s%s" % (dir_path, '/', json_file_name)
connectogram_js_sub = "%s%s%s%s%s%s" % (
dir_path, '/', str(ID), '_connectogram_', conn_model, '.js')
fdg_js_sub = "%s%s%s%s%s%s" % (dir_path, '/', str(ID), '_fdg_',
conn_model, '.js')
fdg_js_sub_name = "%s%s%s%s" % (str(ID), '_fdg_', conn_model, '.js')
connectogram_js_name = "%s%s%s%s" % (str(ID), '_connectogram_',
conn_model, '.js')
save_json(connectogram_plot, output)
# Force-directed graphing
G = nx.from_numpy_matrix(np.round(conn_matrix.astype('float64'), 6))
data = json_graph.node_link_data(G)
data.pop('directed', None)
data.pop('graph', None)
data.pop('multigraph', None)
for k in range(len(data['links'])):
data['links'][k]['value'] = data['links'][k].pop('weight')
for k in range(len(data['nodes'])):
data['nodes'][k]['id'] = str(data['nodes'][k]['id'])
for k in range(len(data['links'])):
data['links'][k]['source'] = str(data['links'][k]['source'])
data['links'][k]['target'] = str(data['links'][k]['target'])
# Add community structure
for k in range(len(data['nodes'])):
data['nodes'][k]['group'] = str(label_arr[0][k])
# Add node labels
for k in range(len(data['nodes'])):
data['nodes'][k]['name'] = str(label_names[k])
out_file = "%s%s%s" % (dir_path, '/', str(json_fdg_file_name))
save_json(out_file, data)
# Copy index.html and json to dir_path
#conn_js_path = '/Users/PSYC-dap3463/Applications/PyNets/pynets/connectogram.js'
#index_html_path = '/Users/PSYC-dap3463/Applications/PyNets/pynets/index.html'
conn_js_path = str(Path(__file__).parent / "connectogram.js")
index_html_path = str(Path(__file__).parent / "index.html")
fdg_replacements_js = {"FD_graph.json": str(json_fdg_file_name)}
replacements_html = {
'connectogram.js': str(connectogram_js_name),
'fdg.js': str(fdg_js_sub_name)
}
fdg_js_path = str(Path(__file__).parent / "fdg.js")
with open(index_html_path) as infile, open(str(dir_path + '/index.html'),
'w') as outfile:
for line in infile:
for src, target in replacements_html.items():
line = line.replace(src, target)
outfile.write(line)
replacements_js = {
'template.json': str(json_file_name),
'interpolateCool': str(color_scheme)
}
with open(conn_js_path) as infile, open(connectogram_js_sub,
'w') as outfile:
for line in infile:
for src, target in replacements_js.items():
line = line.replace(src, target)
outfile.write(line)
with open(fdg_js_path) as infile, open(fdg_js_sub, 'w') as outfile:
for line in infile:
for src, target in fdg_replacements_js.items():
line = line.replace(src, target)
outfile.write(line)
return
def plot_all(conn_matrix, conn_model, atlas_select, dir_path, ID, network,
label_names, mask, coords, thr, node_size, edge_threshold):
import matplotlib
matplotlib.use('Agg')
from matplotlib import pyplot as plt
from nilearn import plotting as niplot
import pkg_resources
import networkx as nx
from pynets import plotting
from pynets.netstats import most_important
try:
import cPickle as pickle
except ImportError:
import _pickle as pickle
pruning = True
dpi_resolution = 500
G_pre = nx.from_numpy_matrix(conn_matrix)
if pruning == True:
[G, pruned_nodes, pruned_edges] = most_important(G_pre)
else:
G = G_pre
conn_matrix = nx.to_numpy_array(G)
pruned_nodes.sort(reverse=True)
for j in pruned_nodes:
del label_names[label_names.index(label_names[j])]
del coords[coords.index(coords[j])]
pruned_edges.sort(reverse=True)
for j in pruned_edges:
del label_names[label_names.index(label_names[j])]
del coords[coords.index(coords[j])]
# Plot connectogram
if len(conn_matrix) > 20:
try:
plotting.plot_connectogram(conn_matrix, conn_model, atlas_select,
dir_path, ID, network, label_names)
except RuntimeError:
print('\n\n\nError: Connectogram plotting failed!')
else:
print(
'Error: Cannot plot connectogram for graphs smaller than 20 x 20!')
# Plot adj. matrix based on determined inputs
plotting.plot_conn_mat_func(conn_matrix, conn_model, atlas_select,
dir_path, ID, network, label_names, mask, thr,
node_size)
# Plot connectome
if mask:
if network:
out_path_fig = "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s" % (
dir_path, '/', ID, '_', str(atlas_select), '_',
str(conn_model), '_', str(
os.path.basename(mask).split('.')[0]), '_', str(network),
'_', str(thr), '_', str(node_size), '_func_glass_viz.png')
else:
out_path_fig = "%s%s%s%s%s%s%s%s%s%s%s%s%s%s" % (
dir_path, '/', ID, '_', str(atlas_select), '_',
str(conn_model), '_', str(
os.path.basename(mask).split('.')[0]), '_', str(thr), '_',
str(node_size), '_func_glass_viz.png')
# Save coords to pickle
coord_path = "%s%s%s%s" % (dir_path, '/coords_',
os.path.basename(mask).split('.')[0],
'_plotting.pkl')
with open(coord_path, 'wb') as f:
pickle.dump(coords, f, protocol=2)
net_parcels_map_nifti = None
# Save labels to pickle
labels_path = "%s%s%s%s" % (dir_path, '/labelnames_',
os.path.basename(mask).split('.')[0],
'_plotting.pkl')
with open(labels_path, 'wb') as f:
pickle.dump(label_names, f, protocol=2)
else:
if network:
out_path_fig = "%s%s%s%s%s%s%s%s%s%s%s%s%s%s" % (
dir_path, '/', ID, '_', str(atlas_select), '_',
str(conn_model), '_', str(network), '_', str(thr), '_',
str(node_size), '_func_glass_viz.png')
else:
out_path_fig = "%s%s%s%s%s%s%s%s%s%s%s%s" % (
dir_path, '/', ID, '_',
str(atlas_select), '_', str(conn_model), '_', str(thr), '_',
str(node_size), '_func_glass_viz.png')
# Save coords to pickle
coord_path = "%s%s" % (dir_path, '/coords_plotting.pkl')
with open(coord_path, 'wb') as f:
pickle.dump(coords, f, protocol=2)
# Save labels to pickle
labels_path = "%s%s" % (dir_path, '/labelnames_plotting.pkl')
with open(labels_path, 'wb') as f:
pickle.dump(label_names, f, protocol=2)
#niplot.plot_connectome(conn_matrix, coords, edge_threshold=edge_threshold, node_size=20, colorbar=True, output_file=out_path_fig)
ch2better_loc = pkg_resources.resource_filename(
"pynets", "templates/ch2better.nii.gz")
connectome = niplot.plot_connectome(np.zeros(shape=(1, 1)), [(0, 0, 0)],
node_size=0.0001)
connectome.add_overlay(ch2better_loc, alpha=0.4, cmap=plt.cm.gray)
[z_min, z_max] = -np.abs(conn_matrix).max(), np.abs(conn_matrix).max()
connectome.add_graph(conn_matrix,
coords,
edge_threshold=edge_threshold,
edge_cmap='Greens',
edge_vmax=z_max,
edge_vmin=z_min,
node_size=4)
connectome.savefig(out_path_fig, dpi=dpi_resolution)
#connectome.savefig(out_path_fig, dpi=dpi_resolution, facecolor ='k', edgecolor ='k')
return
