def make_article_graph(self, layout="arf"):
"""Make an article graph"""
self.graph = Graph(directed=False)
# add vertex
self.graph.add_vertex(len(self.db))
# add properties
cb = self.graph.new_vertex_property("int", self.db['Cited by'].values)
self.graph.vertex_properties['nmb_citation'] = cb
# Add links
auths = list(self.author_betweeness.keys())
auth2ind = {auths[i]: i
for i in range(len(auths))}
auth2pub = self._get_author_publication()
for _, pubs in auth2pub.items():
if len(pubs) < 2:
continue
combis = itertools.combinations(pubs, 2)
self.graph.add_edge_list(list(combis))
# layout
if layout == "arf":
self.layout_pos = arf_layout(self.graph)
elif layout == "sfpd":
self.layout_pos = sfdp_layout(self.graph)
elif layout == "fr":
self.layout_pos = fruchterman_reingold_layout(self.graph)
elif layout == "radial":
self.layout_pos = radial_tree_layout(self.graph,
auth2ind['Logan, B.E.'])
else:
raise ValueError()
def reachability_graphs(self):
for o in self.organisms:
g = self.builder[o].arcgraph
targets = self.targets[o]
root = g.add_vertex()
for v in g.vertices():
if g.vp.is_start_compound[v]:
g.add_edge(root, v)
if g.vp.compound_ids[v] in targets:
g.vp.color[v] = 'green'
helper.add_properties(g)
g.vp.size[root] = 100
old_color = g.vp.color[root]
g.vp.color[root] = "red"
g.vp.besucht[root] = True
visitor = helper.NeighborVisitor(g)
gt.bfs_search(g, root, visitor)
pos = gt.radial_tree_layout(g, g.vertex_index[root], r=0.001)
g.vp.besucht[root] = False
g.set_vertex_filter(g.vp.besucht)
g.vp.size.a = 50 * 0.9**g.vp.dist.a + 10
gt.graph_draw(g,
pos,
vertex_size=g.vp.size,
vertex_text=g.vp.dist,
vertex_text_position=-0.1,
vertex_fill_color=g.vp.color,
vertex_text_color="black",
edge_marker_size=10,
edge_pen_width=0.5,
output_size=(5000, 5000),
output=join(const.MECAT_BASE, 'Targets ' + o,
'reachability.pdf'))
bfs_reachable = list()
for v in g.vertices():
if g.vp.compound_ids[v] in self.targets[o]:
bfs_reachable.append(g.vp.compound_ids[v])
bfs_not_reachable = self.targets[o] - set(bfs_reachable)
self.bfs_reachable[o] = bfs_reachable
self.bfs_not_reachable[o] = bfs_not_reachable
g.clear_filters()
helper.remove_properties(g)
g.vp.color[root] = old_color
def draw(self):
graph_draw(
self.graph,
pos=radial_tree_layout(self.graph, self.graph.vertex(0)),
vertex_text=self.v_names,
vertex_fill_color=self.v_colors,
edge_text=self.e_names,
output_size=(2000, 1300),
fit_view=True,
vertex_font_size=10,
vertex_pen_width=1,
vertex_halo=False,
edge_pen_width=3,
)
def draw(self, file_name, output_size=(1980, 1980)):
# for straight edges, use only one line below instead of the next 5 lines before gt.graph_draw
# tpos = pos = gt.radial_tree_layout(self.g, self.root)
state = gt.minimize_nested_blockmodel_dl(self.g, deg_corr=True)
t = gt.get_hierarchy_tree(state)[0]
tpos = pos = gt.radial_tree_layout(self.g, self.root)
cts = gt.get_hierarchy_control_points(self.g, t, tpos, beta=0.2)
pos = self.g.own_property(tpos)
gt.graph_draw(self.g, bg_color=[1,1,1,1], vertex_text=self.vprop_label, vertex_text_position=self.text_position, \
vertex_text_rotation=self.text_rotation, vertex_fill_color=self.fill_color, \
output=file_name, output_size=output_size, inline=True, vertex_font_size=self.font_size, \
edge_marker_size=self.marker_size, vertex_text_offset=self.text_offset, \
vertex_size=self.vertex_size, vertex_anchor = 0, pos=pos, edge_control_points=cts, fit_view=0.9)
def make_author_graph(self, layout="arf"):
"""Make an author graph"""
self.graph = Graph(directed=False)
# add vertex
auths = self.author_list
self.graph.add_vertex(len(auths))
# add links
auth2ind = {auths[i]: i
for i in range(len(auths))}
abet = []
authbet = copy.deepcopy(self.author_betweeness)
for auth in auths:
for col, weight in authbet[auth].items():
if col == auth:
continue
self.graph.add_edge(auth2ind[auth], auth2ind[col])
del authbet[col][auth] # ensure that edges are not doubled
abet.append(weight)
# add properties
cb = self.graph.new_edge_property("int", abet)
self.graph.edge_properties['weight'] = cb
# layout
if layout == "arf":
self.layout_pos = arf_layout(self.graph,
weight=self.graph.ep.weight,
pos=self.layout_pos,
max_iter=10000)
elif layout == "sfpd":
self.layout_pos = sfdp_layout(self.graph,
eweight=self.graph.ep.weight,
pos=self.layout_pos)
elif layout == "fr":
self.layout_pos = fruchterman_reingold_layout(self.graph,
weight=self.graph.ep.weight,
circular=True,
pos=self.layout_pos)
elif layout == "radial":
nc = self.get_total_citation()
main_auth_ind = np.argmax(list(nc.values()))
main_auth = list(nc.keys())[main_auth_ind]
self.layout_pos = radial_tree_layout(self.graph,
auth2ind[main_auth])
elif layout == "planar":
self.layout_pos = planar_layout(self.graph)
else:
raise ValueError()
def plot_tree(g, ID, max_dist=8, mpl_colormap='viridis', kcore_base=4, return_tree=False):
'''
Automatic plotting of the tree of shortest path.
'''
id_info = ID_TREE(g)
id_info.initialize_id_node_dict()
node_index = id_info.get_node_from_id(ID)
v_list, dist_list = id_info.rank_bfs(source=node_index, max_dist=max_dist)
g_tree = id_info.build_tree(source=node_index, targets=v_list, dist_target=dist_list)
#node_color, node_size = id_info.get_colorcore_map(g_tree)
node_color, node_size = id_info.set_aesthestic(g_tree, kcore_base=kcore_base, mpl_colormap=mpl_colormap)
if return_tree:
return g_tree, node_color, node_size
pos = gt.radial_tree_layout(g_tree, g_tree.vertex(0)) # zero is always the root.
gt.graph_draw(g_tree, pos=pos, vertex_color=node_color, vertex_fill_color=node_color, vertex_size=node_size, edge_pen_width=1.0)
def make_radial_graph(self, **args):
if self.random_state is not None:
np.random.seed(self.random_state)
state = gt.minimize_nested_blockmodel_dl(self.g, deg_corr=True)
t = gt.get_hierarchy_tree(state)[0]
tpos = gt.radial_tree_layout(t,
t.vertex(t.num_vertices() - 1),
weighted=True)
cts = self.g.new_edge_property("double")
pos = self.g.new_edge_property("double")
self.g.edge_properties['cts'] = gt.get_hierarchy_control_points(
self.g, t, tpos)
self.g.vertex_properties['pos'] = self.g.own_property(tpos)
self.membership = list(state.get_bs()[0])
if self.node_color.sum() == 0:
self.node_color = self.convert_str_to_color(self.membership)
self.add_color_nodes()
def __radial_tree_layout(self, net, **params):
"""
:Graph net: A Graph
:int root: The root of the radial tree.
:string rel_order : Attribute name of relative order of the nodes at each respective branch.
:string node_weight : Attribute name of the relative spacing between leafs will correspond to the node weights.
"""
valid_params = {"root": params["root"]}
vparam = ["rel_order", "node_weight"]
for param_name in vparam:
if params[param_name] in net.vp:
valid_params[param_name] = net.vp[params[param_name]]
eparam = []
for param_name in eparam:
if params[param_name] in net.ep:
valid_params[param_name] = net.ep[params[param_name]]
return gt.radial_tree_layout(net, **valid_params)
def build_result_graph(self, reactionlist, product, filename):
g = gt.Graph()
cofactors = [s.id for s in self.cofactor_list]
generic_compound = [s.id for s in self.generic_compound_list]
edges = []
for reaction in self.model.reactions:
for c, val in reaction.reactants.iteritems():
if c not in cofactors and c not in generic_compound:
if val < 0:
edges.append((c, reaction.id))
else:
edges.append((reaction.id, c))
ids = g.add_edge_list(edges, hashed=True, string_vals=True)
g.vertex_properties["ids"] = ids
g.vertex_properties["names"] = g.new_vertex_property("string")
g.vertex_properties["color"] = g.new_vertex_property("string")
g.vertex_properties["size"] = g.new_vertex_property("int")
g.edge_properties["arrows"] = g.new_edge_property("string")
for v in g.vertices():
v_id = g.vp.ids[v]
g.vp.names[v] = v_id
g.vp.color[v] = "red" if v_id in reactionlist else "white"
g.vp.size[v] = 10 if v_id in reactionlist else 3
for e in g.edges():
g.ep.arrows[e] = "none"
root = gt.find_vertex(g, g.vertex_properties["names"], product)[0]
pos = gt.radial_tree_layout(g, g.vertex_index[root])
gt.graph_draw(g,
pos,
vertex_size=g.vp.size,
vertex_text=g.vp.names,
vertex_fill_color=g.vp.color,
edge_pen_width=0.5,
edge_end_marker=g.ep.arrows,
output=filename,
fit_view=True,
output_size=(10000, 10000))
def draw_radial_graph(self,
output_path,
vertex_text=None,
vertex_fill_color=[0.640625, 0, 0, 0.9],
bg_color=(.75, .75, .75, 1),
output_size=(1000, 1000),
vcmap=matplotlib.cm.summer,
**kwargs):
"""
Draws the structureGraph as a radial graph to output_path
:param output_path: path to save the image of the graph to
:return:
"""
pos = gt.radial_tree_layout(self.structureGraph, self.structureGraph.vertex(0))
gt.graph_draw(self.structureGraph,
pos=pos,
output=output_path,
bg_color=bg_color,
vertex_text=vertex_text,
output_size=output_size,
vertex_fill_color=vertex_fill_color,
vcmap=vcmap,
**kwargs)
def target_reachability(self):
# part 1: arcs
g = self.arcgraph.copy()
g.vertex_properties["size"] = g.new_vertex_property("int", val=40)
g.vertex_properties["dist"] = g.new_vertex_property("int", val=0)
g.vertex_properties["besucht"] = g.new_vertex_property("bool", False)
root = g.add_vertex()
for v in g.vertices():
if g.vp.is_start_compound[v]:
g.add_edge(root, v)
if g.vp.compound_ids[v] in self.targets:
g.vp.color[v] = 'green'
helper.add_properties(g)
g.vp.size[root] = 100
g.vp.color[root] = "red"
g.vp.besucht[root] = True
visitor = helper.NeighborVisitor(g)
gt.bfs_search(g, root, visitor)
pos = gt.radial_tree_layout(g, g.vertex_index[root], r=0.001)
g.vp.besucht[root] = False
g.set_vertex_filter(g.vp.besucht)
g.vp.size.a = 50 * 0.9**g.vp.dist.a + 10
bfs_reachable = list()
for v in g.vertices():
if g.vp.compound_ids[v] in self.targets:
bfs_reachable.append(g.vp.compound_ids[v])
bfs_not_reachable = self.targets - set(bfs_reachable)
self.bfs_reachable = sorted(bfs_reachable)
self.bfs_not_reachable = sorted(bfs_not_reachable)
assert len(bfs_reachable) + len(bfs_not_reachable) == len(self.targets)
with open(join(self.statistics_path, "bfs_reachable.txt"), 'w') as f:
for id in self.bfs_reachable:
c = self.compounds[id]
f.write("{}\t{}\n".format(id, c.names[0]))
with open(join(self.statistics_path, "bfs_not_reachable.txt"),
'w') as f:
for id in self.bfs_not_reachable:
c = self.compounds[id]
f.write("{}\t{}\n".format(id, c.names[0]))
g.set_vertex_filter(None)
# part 2: reactions
model_reactions = {r.id: r for r in self.model_reactions}
feasible_reactions = self.builder.feasible_reaction_list
feasible_targets = set()
not_feasible_targets = set()
predicted_targets = set()
for c in self.targets:
reactions_for_target = self.__reactions_for_target(
c, model_reactions)
fr = set(reactions_for_target) & feasible_reactions
if len(fr) > 0:
predicted_targets.add(c)
if c in self.bfs_reachable:
feasible_targets.add(c)
else:
if c in self.bfs_reachable:
not_feasible_targets.add(c)
with open(join(self.statistics_path, "target_is_feasible.txt"),
'w') as f:
for id in sorted(feasible_targets):
c = self.compounds[id]
f.write("{}\t{}\n".format(id, c.names[0]))
numt = len(self.targets) # all targets
numbfsf = len(bfs_reachable) # BFS reachable
numf = len(feasible_targets) # feasible targets
nump = len(predicted_targets) # predicted targets
p = numf / numt * 100
with open(join(const.MECAT_BASE, 'target_table.txt'), 'a') as f:
f.write(self.name + ' & ' + str(numt) + ' & ' + str(numbfsf) +
' & ' + str(nump) + ' & ' + str(numf) + ' & ' +
str(int(round(p, 0))) + '\%' + '\\\\ \n')
def codon_circos(cmap='tab20', filetype="pdf", reverse=False):
cm = plt.cm.get_cmap(cmap)
cmappable = ScalarMappable(norm=Normalize(vmin=0, vmax=20), cmap=cm)
g_codons = gt.Graph(directed=False)
g_codons.vp.codon = g_codons.new_vertex_property("string")
g_codons.vp.aa = g_codons.new_vertex_property("string")
g_codons.vp.aa_index = g_codons.new_vertex_property("int")
g_codons.vp.aa_color = g_codons.new_vertex_property("vector<float>")
g_codons.vp.codon_index = g_codons.new_vertex_property("int")
g_codons.ep.syn = g_codons.new_edge_property("bool")
g_codons.ep.grad = g_codons.new_edge_property("vector<float>")
for aa_index, aa in enumerate(aa_order):
if aa == "X": continue
for codon_index, c in enumerate(sorted([k for k, v in codontable.items() if v == aa])):
v = g_codons.add_vertex()
g_codons.vp.codon[v] = c
g_codons.vp.aa[v] = aa
g_codons.vp.codon_index[v] = codon_index
g_codons.vp.aa_index[v] = aa_index
g_codons.vp.aa_color[v] = cmappable.to_rgba(aa_index)
for ref in g_codons.vertices():
for alt in g_codons.vertices():
if alt <= ref: continue
codon_ref, codon_alt = g_codons.vp.codon[ref], g_codons.vp.codon[alt]
if distance_str(codon_ref, codon_alt) != 1: continue
if codontable[codon_ref] != codontable[codon_alt]:
e_c = g_codons.add_edge(ref, alt)
g_codons.ep.syn[e_c] = False
x = cmappable.to_rgba(g_codons.vp.aa_index[ref])[:3]
y = cmappable.to_rgba(g_codons.vp.aa_index[alt])[:3]
if reverse: x, y = y, x
g_codons.ep.grad[e_c] = [0.0, *x, 0.75, 1.0, *y, 0.75]
for ref in g_codons.vertices():
for alt in g_codons.vertices():
if alt >= ref: continue
codon_ref, codon_alt = g_codons.vp.codon[ref], g_codons.vp.codon[alt]
if distance_str(codon_ref, codon_alt) != 1: continue
if codontable[codon_ref] == codontable[codon_alt]:
e_c = g_codons.add_edge(ref, alt)
g_codons.ep.syn[e_c] = True
syn_color = 0.0, 0.0, 0.0, 1.0
g_codons.ep.grad[e_c] = [0.0, *syn_color, 1.0, *syn_color]
assert g_codons.num_vertices() == 61
dist = gt.shortest_distance(g_codons)
r = max([max(dist[g_codons.vertex(i)].a) for i in g_codons.vertices()])
print('Codons graph radius : {0}'.format(r))
print('Codons : {0} transitions out of {1} possibles.'.format(g_codons.num_edges(), 61 * 60 / 2))
syn_array = g_codons.ep.syn.get_array()
print('Codons : {0} are synonymous and {1} are non-synonymous.'.format(sum(syn_array),
len(syn_array) - sum(syn_array)))
state = gt.NestedBlockState(g_codons, bs=[g_codons.vp.aa_index, g_codons.vp.codon_index], sampling=False)
t = gt.get_hierarchy_tree(state)[0]
tpos = gt.radial_tree_layout(t, t.vertex(t.num_vertices() - 1), weighted=True)
cts = gt.get_hierarchy_control_points(g_codons, t, tpos)
pos = g_codons.own_property(tpos)
gt.graph_draw(g_codons, pos=pos, edge_control_points=cts, edge_gradient=g_codons.ep.grad, edge_pen_width=2.5,
vertex_text=g_codons.vp.codon, vertex_anchor=0, vertex_font_size=9, vertex_pen_width=1.6,
vertex_color=(0.65, 0.65, 0.65, 1), vertex_fill_color=g_codons.vp.aa_color, vertex_size=25.0,
output="gt-codon-{0}.{1}".format(cmap, filetype))
def amino_acid_circos(cmap='tab20', filetype="pdf", reverse=False):
cm = plt.cm.get_cmap(cmap)
cmappable = ScalarMappable(norm=Normalize(vmin=0, vmax=20), cmap=cm)
g_aa = gt.Graph(directed=False)
g_aa.vp.aa = g_aa.new_vertex_property("string")
g_aa.vp.aa_color = g_aa.new_vertex_property("vector<float>")
g_aa.vp.count = g_aa.new_vertex_property("float")
g_aa.ep.count = g_aa.new_edge_property("float")
g_aa.ep.grad = g_aa.new_edge_property("vector<float>")
for aa_index, aa in enumerate(aa_order):
if aa == "X": continue
v = g_aa.add_vertex()
g_aa.vp.aa[v] = aa
g_aa.vp.aa_color[v] = cmappable.to_rgba(aa_index)
g_aa.vp.count[v] = np.sqrt(len([k for k, v in codontable.items() if v == aa])) * 28
adj = np.zeros((g_aa.num_vertices(), g_aa.num_vertices()))
for ref_index, ref in enumerate(g_aa.vertices()):
for alt_index, alt in enumerate(g_aa.vertices()):
if alt <= ref: continue
aa_ref, aa_alt = g_aa.vp.aa[ref], g_aa.vp.aa[alt]
c_ref = [k for k, v in codontable.items() if v == aa_ref]
c_alt = [k for k, v in codontable.items() if v == aa_alt]
nei = [(r, a) for r, a in product(c_ref, c_alt) if distance_str(r, a) == 1]
if len(nei) > 0:
e_aa = g_aa.add_edge(ref, alt)
x = cmappable.to_rgba(ref_index)[:3]
y = cmappable.to_rgba(alt_index)[:3]
if reverse: x, y = y, x
g_aa.ep.grad[e_aa] = [0.0, *x, 0.75, 1.0, *y, 0.75]
g_aa.ep.count[e_aa] = len(nei) * 2.0
adj[ref_index, alt_index] = len(nei)
table = open("aa-adjacency.tex", "w")
table.writelines("\\begin{table}[H]\n\\centering\n")
table.writelines("\\begin{tabular}{|c||" + "c|" * g_aa.num_vertices() + "}\n")
table.writelines("\\hline & ")
table.writelines(" & ".join(map(lambda x: "\\textbf{" + x + "}", g_aa.vp.aa)) + "\\\\\n")
table.writelines("\\hline\n\\hline ")
for i in range(adj.shape[0]):
elts = ["\\textbf{" + g_aa.vp.aa[i] + "}"]
for j in range(adj.shape[1]):
if i < j:
elts.append("{:d}".format(int(adj[i][j])))
else:
elts.append("-")
table.writelines(" & ".join(elts) + "\\\\\n\\hline ")
table.writelines("\\end{tabular}\n")
table.writelines("\\caption[]{}\n")
table.writelines("\\end{table}\n")
table.close()
assert g_aa.num_vertices() == 20
dist = gt.shortest_distance(g_aa)
r = max([max(dist[g_aa.vertex(i)].a) for i in g_aa.vertices()])
print('Amino acids graph radius : {0}'.format(r))
dict_distance = {1: [], 2: [], 3: []}
for source in g_aa.vertices():
for target in g_aa.vertices():
if source <= target: continue
dict_distance[int(gt.shortest_distance(g_aa, source, target))].append(
"{0}-{1}".format(g_aa.vp.aa[source], g_aa.vp.aa[target]))
for k, v in dict_distance.items():
print("d={0}: {1} pairs".format(k, len(v)))
print(", ".join(v))
print('Amino acids : {0} transitions out of {1} possibles '.format(g_aa.num_edges(), 20 * 19 / 2))
state = gt.minimize_nested_blockmodel_dl(g_aa, deg_corr=True)
t = gt.get_hierarchy_tree(state)[0]
tpos = gt.radial_tree_layout(t, t.vertex(t.num_vertices() - 1), weighted=True)
cts = gt.get_hierarchy_control_points(g_aa, t, tpos)
pos = g_aa.own_property(tpos)
gt.graph_draw(g_aa, pos=pos, edge_control_points=cts, vertex_anchor=0, vertex_text=g_aa.vp.aa,
vertex_fill_color=g_aa.vp.aa_color, vertex_size=g_aa.vp.count, vertex_font_size=16,
vertex_pen_width=3.2, vertex_color=(0.65, 0.65, 0.65, 1),
edge_gradient=g_aa.ep.grad, edge_pen_width=g_aa.ep.count,
output="gt-aa-{0}.{1}".format(cmap, filetype))
import graph_tool.all as gt
import numpy as np
from sys import exit
adj = np.genfromtxt('C.dat')
g = gt.Graph(directed=False)
# g.add_edge_list(adj.nonzero())
g.add_vertex(len(adj))
edge_weights = g.new_edge_property('double')
num_vertices = adj.shape[0]
for i in range(num_vertices - 1):
for j in range(i + 1, num_vertices):
if adj[i, j] != 0:
e = g.add_edge(i, j)
edge_weights[e] = adj[i, j]
# pos = gt.arf_layout(g, max_iter=0)
pos = gt.radial_tree_layout(g, g.vertex(0))
gt.graph_draw(g, output="radial_tree_layout.pdf")
state = gt.minimize_nested_blockmodel_dl(g)
gt.draw_hierarchy(state, output="celegansneural_nested_mdl.pdf")
def draw_graph(self, e_label, output, v_label='idx'):
"""
Helper for convienient and consistent graph drawing.
@param output filepath of desired output file (pdf)
"""
return
s = self.simulation
g = self.graph
# Update position if the topology changed.
if self.pos_dirty:
# Calculate pos once to be used by all other graphs
#self.pos = gt.sfdp_layout(g, K=100, C=0.1, gamma=10.0, mu=0.0)
#self.pos = gt.sfdp_layout(g, gamma=10.0)
#self.pos = gt.sfdp_layout(g, gamma=200.0)
#self.pos = gt.arf_layout(g, d=5.0, a=10, dt=0.001, epsilon=1e-06, max_iter=1000)
#self.pos = gt.radial_tree_layout(g, self.driveswitch)
self.pos = gt.radial_tree_layout(g, self.mainswitch)
self.pos_dirty = False
if type(e_label) is str:
ep = g.ep[e_label]
else:
ep = e_label
# Set node fill color depending on certain criteria: busy
busy_fill = g.new_vertex_property('vector<double>')
for v in g.vertices():
if g.vp['obj'][v].has_capacity():
busy_fill[v] = [1,1,1,1]
else:
busy_fill[v] = [1,0,0,0.5]
# Prepare label text and ensure all labels are converted to be strings
edge_label = g.new_edge_property("string")
gt.map_property_values(ep, edge_label, lambda x: str(x))
# Adjust vertex label depending on type.
if v_label != None:
if v_label == 'idx':
vertex_label = g.copy_property(g.vp['name'])
for v in g.vertices():
vertex_label[v] = str(int(v)) + "::" + vertex_label[v]
else:
# prepare vertex label text
if type(v_label) is str:
vp = g.vp[e_label]
else:
vp = v_label
vertex_label = g.new_edge_property("string")
# ensure strings
gt.map_property_values(vp, vertex_label, lambda x: str(x))
else:
vertex_label = g.vp['name']
pos = self.pos
gt.graph_draw(g, pos=pos,
output_size=(800, 600),
vertex_text=vertex_label,
vertex_shape = 'circle',
#vertex_shape = 'square',
#vertex_aspect = 2.0,
vertex_pen_width = 0.5,
vertex_fill_color = busy_fill, # TODO
vertex_color = [0,0,0,1],
vertex_text_color = [0,0,0,0.8],
vertex_font_family = 'sans-serif',
vertex_font_size = 10,
vertex_font_weight = cairo.FONT_WEIGHT_BOLD,
edge_pen_width=gt.prop_to_size(ep, mi=1, ma=15, power=1),
edge_text=edge_label,
edge_end_marker = 'bar',
#edge_marker_size = 4,
edge_font_family = 'sans-serif',
edge_font_size = 8,
edge_color = [0,0,0,0.2],
output=output)
def circular_depgraph(g,
plot_type="graph",
save_as="~/depgraph.png",
):
save_as = os.path.abspath(os.path.expanduser(save_as))
state = gt.minimize_nested_blockmodel_dl(g, deg_corr=True)
t = gt.get_hierarchy_tree(state)[0]
tpos = pos = gt.radial_tree_layout(t, t.vertex(t.num_vertices() - 1), weighted=True)
cts = gt.get_hierarchy_control_points(g, t, tpos)
pos = g.own_property(tpos)
vtext_rotation = g.new_vertex_property('double')
g.vertex_properties['vtext_rotation'] = vtext_rotation
for v in g.vertices():
#set vtext_rotation
if pos[v][0] >= 0:
try:
vtext_rotation[v] = math.atan(pos[v][1]/pos[v][0])
except ZeroDivisionError:
vtext_rotation[v] = 0
else:
vtext_rotation[v] = math.pi + math.atan(pos[v][1]/pos[v][0])
#here we do black magic to get proper output size (controls vertex spacing) and scaling
vertex_number = g.num_vertices()
view_zoom = (vertex_number*36.0485)**(-10.068/vertex_number)+0.017037
output_size = int(vertex_number*5.9+400)
dpi=300
if output_size >= 18000:
print("WARNING: You are exceding the maximal printable size - 150cm in one dimension at 300dpi")
print("Plotting dependency graph containing {0} packages, at a resolution of {1} pixels by {1} pixels".format(vertex_number, output_size))
if plot_type == "graph":
gt.graph_draw(g, pos=pos,
edge_control_points=cts,
vertex_anchor=0,
vertex_color=g.vertex_properties['vcolor'],
vertex_fill_color=g.vertex_properties['vcolor'],
vertex_font_size=14,
vertex_text=g.vertex_properties['vlabel'],
vertex_text_position=6.2,
vertex_text_rotation=g.vertex_properties['vtext_rotation'],
vertex_text_color=g.vertex_properties['vtext_color'],
vertex_size=16,
edge_start_marker="none",
edge_mid_marker="none",
edge_end_marker="none",
edge_gradient=g.edge_properties["egradient"],
eorder=g.edge_properties["eorder"],
bg_color=[1,1,1,1],
output_size=[output_size,output_size],
output=save_as,
fit_view=view_zoom,
)
elif plot_type == "state":
gt.draw_hierarchy(state,
vertex_text_position=1,
vertex_font_size=12,
vertex_text=g.vertex_properties['label'],
vertex_text_rotation=g.vertex_properties['text_rotation'],
vertex_anchor=0,
bg_color=[1,1,1,1],
output_size=[output_size,output_size],
output=save_as,
)
help='option number')
args = parser.parse_args()
myfile = args.threshold[0]
# nested block model
#state = utils.pickleLoad('graph_pagerank_purge_%s_nested.pk1' % threshold)
state = utils.pickleLoad(myfile)
# underlying graph
g = state.g
t = gt.get_hierarchy_tree(state)[0]
tpos = pos = gt.radial_tree_layout(t, t.vertex(t.num_vertices() - 1), weighted=True)
pos = g.own_property(tpos)
text_rot = g.new_vertex_property('double')
g.vertex_properties['text_rot'] = text_rot
cts = gt.get_hierarchy_control_points(g, t, tpos)
for v in g.vertices():
if pos[v][0] > 0:
text_rot[v] = math.atan(pos[v][1]/pos[v][0])
else:
text_rot[v] = math.pi + math.atan(pos[v][1]/pos[v][0])
#orange on dem -> rep
edge_color[e] = (255.0 / 255.0, 102 / 255.0, 0 / 255.0, alpha)
else:
edge_color[e] = (102.0 / 255.0, 51 / 255.0, 153 / 255.0, alpha)
#red on rep-rep edges
elif plot_color[e.source()] == (1, 0, 0, 1):
edge_color[e] = (1, 0, 0, alpha)
#blue on dem-dem edges
else:
edge_color[e] = (0, 0, 1, alpha)
state = gt.minimize_nested_blockmodel_dl(g, deg_corr=True)
bstack = state.get_bstack()
t = gt.get_hierarchy_tree(bstack)[0]
tpos = pos = gt.radial_tree_layout(t,
t.vertex(t.num_vertices() - 1),
weighted=True)
cts = gt.get_hierarchy_control_points(g, t, tpos)
pos = g.own_property(tpos)
b = bstack[0].vp["b"]
#labels
text_rot = g.new_vertex_property('double')
g.vertex_properties['text_rot'] = text_rot
for v in g.vertices():
if pos[v][0] > 0:
text_rot[v] = math.atan(pos[v][1] / pos[v][0])
else:
text_rot[v] = math.pi + math.atan(pos[v][1] / pos[v][0])
gt.graph_draw(g,
diffusion_tree.add_edge(edge[0], edge[1])
pos2 = gt.fruchterman_reingold_layout(diffusion_tree)
#pos2 = gt.sfdp_layout(diffusion_tree)
for i in range(count):
pos2[i] = pos1[i]
gt.graph_draw(diffusion_tree,
pos=pos2,
vprops={
"size": 5,
"fill_color": color_list[color_index]
},
eprops={
"color": [0.5, 0.5, 0.5, 0.5],
"marker_size": 4
},
output_size=(400, 400),
output="diffusion.eps")
pos3 = gt.radial_tree_layout(diffusion_tree, diffusion_tree.vertex(dat[0]))
gt.graph_draw(diffusion_tree,
pos=pos3,
vprops={
"size": 5,
"fill_color": color_list[color_index]
},
eprops={
"color": [0.5, 0.5, 0.5, 0.5],
"marker_size": 4
},
output_size=(400, 400),
output="diffusion_ra.eps")
def draw_graph(self, e_label, output, v_label='idx'):
"""
Helper for convienient and consistent graph drawing.
@param output filepath of desired output file (pdf)
"""
return
s = self.simulation
g = self.graph
# Update position if the topology changed.
if self.pos_dirty:
# Calculate pos once to be used by all other graphs
#self.pos = gt.sfdp_layout(g, K=100, C=0.1, gamma=10.0, mu=0.0)
#self.pos = gt.sfdp_layout(g, gamma=10.0)
#self.pos = gt.sfdp_layout(g, gamma=200.0)
#self.pos = gt.arf_layout(g, d=5.0, a=10, dt=0.001, epsilon=1e-06, max_iter=1000)
#self.pos = gt.radial_tree_layout(g, self.driveswitch)
self.pos = gt.radial_tree_layout(g, self.mainswitch)
self.pos_dirty = False
if type(e_label) is str:
ep = g.ep[e_label]
else:
ep = e_label
# Set node fill color depending on certain criteria: busy
busy_fill = g.new_vertex_property('vector<double>')
for v in g.vertices():
if g.vp['obj'][v].has_capacity():
busy_fill[v] = [1, 1, 1, 1]
else:
busy_fill[v] = [1, 0, 0, 0.5]
# Prepare label text and ensure all labels are converted to be strings
edge_label = g.new_edge_property("string")
gt.map_property_values(ep, edge_label, lambda x: str(x))
# Adjust vertex label depending on type.
if v_label != None:
if v_label == 'idx':
vertex_label = g.copy_property(g.vp['name'])
for v in g.vertices():
vertex_label[v] = str(int(v)) + "::" + vertex_label[v]
else:
# prepare vertex label text
if type(v_label) is str:
vp = g.vp[e_label]
else:
vp = v_label
vertex_label = g.new_edge_property("string")
# ensure strings
gt.map_property_values(vp, vertex_label, lambda x: str(x))
else:
vertex_label = g.vp['name']
pos = self.pos
gt.graph_draw(
g,
pos=pos,
output_size=(800, 600),
vertex_text=vertex_label,
vertex_shape='circle',
#vertex_shape = 'square',
#vertex_aspect = 2.0,
vertex_pen_width=0.5,
vertex_fill_color=busy_fill, # TODO
vertex_color=[0, 0, 0, 1],
vertex_text_color=[0, 0, 0, 0.8],
vertex_font_family='sans-serif',
vertex_font_size=10,
vertex_font_weight=cairo.FONT_WEIGHT_BOLD,
edge_pen_width=gt.prop_to_size(ep, mi=1, ma=15, power=1),
edge_text=edge_label,
edge_end_marker='bar',
#edge_marker_size = 4,
edge_font_family='sans-serif',
edge_font_size=8,
edge_color=[0, 0, 0, 0.2],
output=output)
# <codecell>
import numpy
u = gt.GraphView(f_g, vfilt=gt.label_largest_component(f_g))
deg = u.degree_property_map('total', weight = f_g.edge_properties['cofield'])
deg.fa = 2*(numpy.sqrt(deg.fa)*0.5 + 0.4)
edg = f_g.edge_properties['cofield']
edg.fa = (numpy.sqrt(edg.fa)*0.6+1)
ebet = gt.betweenness(f_g)[1]
# <codecell>
# <codecell>
pos, int = gt.interactive_window(u, pos=gt.radial_tree_layout(f_g, f_g.vertex(1)),
vertex_size = deg,
vertex_fill_color = v_comm,
vertex_text = f_g.vertex_properties['field'],
vertex_text_position = 0.2,
vertex_font_size = 9,
vertex_font_family = 'sans serif',
edge_pen_width = edg,
edge_color=ebet,
output_size = (800,1200)
)
# <codecell>
# <codecell>
def Stochastic():
import pandas as pd
import numpy as np
import pprint as pp
import locale
import matplotlib.pyplot as plt
import matplotlib.ticker as tkr
import graph_tool.all as gt
import math
# Need to drag this out into the real world
from GAC_Graph_Builder import findEdges
t = gt.Graph(directed=True)
tprop_label = t.new_vertex_property("string")
tprop_instType = t.new_vertex_property("string")
linkDict, instSet = findEdges()
# ingest our university checking lists [this is sloppy, TBI]
foreignUniTxt = open('Workaround txts/Foreign Unis.txt', 'r')
UKUniTxt = open('Workaround txts/UK Unis.txt', 'r')
forerignUniVals = foreignUniTxt.read().splitlines()
UKUniVals = UKUniTxt.read().splitlines()
# add vertices and label them based on their names.
######## FILTERING BASED ON CORDIS RESIDENCY ##########
dfCordisNames = pd.read_pickle('Pickles/CORDIS_Countries.pickle')
eligiblenames = dfCordisNames.name.values.tolist()
veryDirtyWorkaround = ['FOCUS', 'FLUOR', 'GE', 'NI', 'OTE', 'ROKE']
for inst in instSet:
nameCheck = inst.upper()
firstFound = next((x for x in eligiblenames if nameCheck in x), None)
if inst in forerignUniVals:
del (linkDict[inst])
elif nameCheck in veryDirtyWorkaround:
del (linkDict[inst])
elif firstFound is None:
del (linkDict[inst])
else:
vert = t.add_vertex()
tprop_label[vert] = str(inst)
del (linkDict[''])
# internalise property map
t.vertex_properties["label"] = tprop_label
# explicitly declare the hierarchy defining vertices and edges, the sequencing here matters.
for_uni = t.add_vertex()
UK_uni = t.add_vertex()
other = t.add_vertex()
root = t.add_vertex()
edgeList = [(root, for_uni), (root, UK_uni), (root, other)]
t.add_edge_list(edgeList)
# use label name to add edges to hierarchy
for i in range(t.num_vertices())[:-4]:
if tprop_label[i] in forerignUniVals:
t.add_edge(for_uni, t.vertex(i))
tprop_instType[i] = "Foreign Uni"
elif tprop_label[i] in UKUniVals:
t.add_edge(UK_uni, t.vertex(i))
tprop_instType[i] = "UK Uni"
else:
t.add_edge(other, t.vertex(i))
tprop_instType[i] = "Other Institution"
t.vertex_properties["instType"] = tprop_instType
tpos = gt.radial_tree_layout(t,
t.vertex(t.num_vertices() - 1),
rel_order_leaf=True)
######### MAIN GRAPH DRAWING ################
g = gt.Graph(directed=False)
# creates graph g, using the same nodes (with the same index!)
for v in t.vertices():
gv = g.add_vertex()
# we remove: root, for_uni, uk_uni or 'other' vertices
lower = g.num_vertices() - 5
current = g.num_vertices() - 1
while current > lower:
g.remove_vertex(current)
current -= 1
# Pull vertex properties from t
labelDict = t.vertex_properties["label"]
instTypeDict = t.vertex_properties["instType"]
# create properties for g vertices
gprop_label = g.new_vertex_property("string")
gprop_instType = g.new_vertex_property("string")
# match labels between g and t
for v in g.vertices():
gprop_label[v] = labelDict[v]
gprop_instType[v] = instTypeDict[v]
# make property map internal to graph g
g.vertex_properties["label"] = gprop_label
g.vertex_properties["instType"] = gprop_instType
###### COLOUR VERTICES #########
# Reclaim variable names because lazy
gprop_vcolour = g.new_vertex_property("string")
for v in g.vertices():
if gprop_instType[v] == "Foreign Uni":
gprop_vcolour[v] = "red"
elif gprop_instType[v] == "UK Uni":
gprop_vcolour[v] = "blue"
else:
gprop_vcolour[v] = "white"
g.vertex_properties["vcolour"] = gprop_vcolour
# create numLinks edge property for g edges
eprop_numLinks = g.new_edge_property("int")
# creates the edges between nodes
for i in linkDict:
for n in linkDict[i]:
#print(i)
vertex_i = gt.find_vertex(g, gprop_label, i)[0]
#print(n)
try:
vertex_n = gt.find_vertex(g, gprop_label, n)[0]
e = g.add_edge(vertex_i, vertex_n)
eprop_numLinks[e] = linkDict[i][n]
except:
IndexError
##### EXPERIMENTAL SIZE THINGS ######
#gvprop_size = g.new_vertex_property('float')
deleteList = []
for v in g.vertices():
# sum the num edges and the number of links they correspond to
# use this to find a ratio and scale size off of this.
numEdges = sum(1 for _ in v.all_edges())
numLinks = 0
for e in v.all_edges():
numLinks += eprop_numLinks[e]
#print(gprop_label[v])
print("NumEdges = " + str(numEdges) + " NumLinks = " + str(numLinks))
# create a delete list
try:
ratio = (numLinks / numEdges) * 5 * 2
except:
ZeroDivisionError
deleteList.append(v)
#gvprop_size[v] = ratio
#g.vertex_properties['size'] = gvprop_size
#### Delete linkless vertices #######
for v in reversed(sorted(deleteList)):
g.remove_vertex(v)
for v in reversed(sorted(deleteList)):
t.remove_vertex(v)
tpos = gt.radial_tree_layout(t,
t.vertex(t.num_vertices() - 1),
rel_order_leaf=True)
#######
############ stochastic BLOCK MODEL ####################
state = gt.minimize_nested_blockmodel_dl(g, deg_corr=True, verbose=True)
t = gt.get_hierarchy_tree(state)[0]
tpos = pos = gt.radial_tree_layout(t,
t.vertex(t.num_vertices() - 1),
weighted=True)
# in order to make sure labels fit in the image we have to manually adjust the
# co-ordinates of each vertex.
x, y = gt.ungroup_vector_property(tpos, [0, 1])
x.a = (x.a - x.a.min()) / (x.a.max() - x.a.min()) * 1400 + 400
y.a = (y.a - y.a.min()) / (y.a.max() - y.a.min()) * 1400 + 400
tpos = gt.group_vector_property([x, y])
# This draws the 'Bezier spline control points' for edges
# it draws the edges directed in graph g, but uses the hierarchy / positioning of graph t.
cts = gt.get_hierarchy_control_points(g, t, tpos)
pos = g.own_property(tpos)
gt.graph_draw(
g,
vertex_text_position="centered",
vertex_text=g.vertex_properties["label"],
vertex_font_size=14,
vertex_anchor=0,
vertex_aspect=1,
vertex_shape="square",
vertex_fill_color=g.vertex_properties["vcolour"],
vertex_size=10,
fit_view=False,
# edge_color=g.edge_properties["colour"],
# edge_pen_width=g.edge_properties["thickness"],
edge_end_marker="none",
edge_pen_width=0.2,
edge_color="white",
bg_color=[0, 0, 0, 1],
output_size=[2000, 2000],
output='UK_ONLY_RELATIONSHIPS_stochastic.png',
pos=pos,
edge_control_points=cts)
if __name__ == '__main__':
pyjd.setup("Hello.html")
# use label name to add edges to hierarchy
for i in range(t.num_vertices())[:-4]:
if tprop_label[i] in forerignUniVals:
t.add_edge(for_uni, t.vertex(i))
tprop_instType[i] = "Foreign Uni"
elif tprop_label[i] in UKUniVals:
t.add_edge(UK_uni, t.vertex(i))
tprop_instType[i] = "UK Uni"
else:
t.add_edge(other, t.vertex(i))
tprop_instType[i] = "Other Institution"
t.vertex_properties["instType"] = tprop_instType
tpos = gt.radial_tree_layout(t, t.vertex(t.num_vertices() -1), rel_order_leaf = True)
######### MAIN GRAPH DRAWING ################
g = gt.Graph(directed = False)
# creates graph g, using the same nodes (with the same index!)
for v in t.vertices():
gv = g.add_vertex()
# we remove: root, for_uni, uk_uni or 'other' vertices
lower = g.num_vertices() - 5
current = g.num_vertices() - 1