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