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_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 get_hierarchy_gt(graph_json, state): # Get the partition from blocks levels = state.get_levels() level_num = len(levels) level_block_count = [] for level in range(0, level_num): level_block_count.append(levels[level].B) level = 0 tree, label, order = gt.get_hierarchy_tree(state) for v_idx in tree.get_vertices(): v = tree.vertex(v_idx) label_v = label[v] # A new level if v_idx != 0 and label_v == 0: level += 1 assert v_idx == len(graph_json['nodes']) node = { 'label': 'node_' + str(v_idx), 'idx': int(v_idx), 'height': level, 'ancIdx': None, 'childIdx': [] } # Virtual Node if level == 0: node['virtualNode'] = False else: node['virtualNode'] = True # Hierarchy if level != 0: for vertex in v.out_neighbors(): node['childIdx'].append(int(vertex)) graph_json['nodes'][int(vertex)]['ancIdx'] = int(v_idx) graph_json['nodes'].append(node) graph_json['rootIdx'] = len(graph_json['nodes']) - 1
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")
def draw_graph( adata: AnnData, layout: _Layout = 'sfdp', # init_pos: Union[str, bool, None] = None, # root: Optional[int] = None, use_tree: bool = False, random_seed: Optional[int] = None, adjacency: Optional[spmatrix] = None, key_added_ext: Optional[str] = None, key: Optional[str] = 'schist', copy: bool = False, **kwds, ): """\ Extends scanpy.tools.draw_graph function using some layouts available in graph-tool library. Three layouts are available here: - SFDP spring-block layout. - ARF spring-block layout. - Fruchterman-Reingold spring-block layout. Fruchterman-Reingold is already available in scanpy, but here can be used to render the nested model tree. In order to use these plotting function, the NestedBlockState needs to be saved when building the model, so `save_state=True` needs to be set. Parameters ---------- adata Annotated data matrix. A NestedBlockState object needs to be saved layout A layout among 'sfdp', 'fr' or 'arf'. Other graph-tool layouts haven't been implemented. use_tree When this is set, the tree of the nested model is used to generate layout, otherwise the layout only accounts for the neighborhood graph. random_seed Random number to be used as seed for graph-tool adjacency Sparse adjacency matrix of the graph, defaults to `adata.uns['neighbors']['connectivities']`. key_added_ext By default, append `layout`. key The slot in `AnnData.uns` containing the state. Default is 'nsbm' copy Return a copy instead of writing to adata. **kwds Parameters of chosen igraph layout. See e.g. `fruchterman-reingold`_ [Fruchterman91]_. One of the most important ones is `maxiter`. .. _fruchterman-reingold: http://igraph.org/python/doc/igraph.Graph-class.html#layout_fruchterman_reingold Returns ------- Depending on `copy`, returns or updates `adata` with the following field. **X_draw_graph_layout** : `adata.obsm` Coordinates of graph layout. E.g. for layout='fa' (the default), the field is called 'X_draw_graph_fa' """ if random_seed: np.random.seed(random_seed) gt.seed_rng(random_seed) n_cells = adata.shape[0] start = logg.info(f'drawing single-cell graph using layout {layout!r}') if layout not in _LAYOUTS: raise ValueError(f'Provide a valid layout, one of {_LAYOUTS}.') adata = adata.copy() if copy else adata if adjacency is None and 'neighbors' not in adata.uns: raise ValueError('You need to run `pp.neighbors` first ' 'to compute a neighborhood graph.') if not key in adata.uns: raise ValueError( 'You need to run `nested_model` before trying to run this function ' ) if use_tree and 'state' not in adata.uns[key]: raise ValueError( 'When `use_tree` is set to `True`, a state should be saved' 'running `nested_model(adata, save_state=True)`.') if adjacency is None: adjacency = adata.uns['neighbors']['connectivities'] g = get_graph_tool_from_adjacency(adjacency) weights = g.ep['weight'] if use_tree: state = state_from_blocks(adata) g, _, _ = gt.get_hierarchy_tree(state, empty_branches=False) weights = None # actual drawing positions = np.zeros((n_cells, 2)) if layout == 'fr': positions = gt.fruchterman_reingold_layout(g, weight=weights) positions = np.array([x for x in positions][:n_cells]) elif layout == 'sfdp': positions = gt.sfdp_layout(g) positions = np.array([x for x in positions][:n_cells]) elif layout == 'arf': positions = gt.arf_layout(g) positions = np.array([x for x in positions][:n_cells]) adata.uns['draw_graph'] = {} adata.uns['draw_graph']['params'] = dict(layout=layout, random_seed=random_seed) key_added = f'X_draw_graph_{layout}' adata.obsm[key_added] = positions logg.info( ' finished', time=start, deep=('added\n' f' {key_added!r}, graph_drawing coordinates (adata.obsm)'), ) return adata if copy else None
if plot_color[e.source()] != plot_color[e.target()]: if plot_color[e.source()] == (0, 0, 1, 1): #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])
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))
def getTreeTop(state,centrality=gt.pagerank,directed=True,fulltree=False): g = state.g visited = [] g.set_directed(directed) label = g.vertex_properties['label'] nodeid = g.vertex_properties['nodeid'] tree, inlevelblocklabels, order = gt.get_hierarchy_tree(state) if fulltree: treetop = tree treetop_label = treetop.new_vertex_property('string') for v in treetop.vertices(): if treetop.vertex_index[v] < g.num_vertices(): treetop_label[v] = label[v] else: treetop = gt.GraphView(tree,vfilt=lambda v: tree.vertex_index[v] >= g.num_vertices()) treetop_label = treetop.new_vertex_property('string') dangling = treetop.new_vertex_property('bool') treecentrality = treetop.new_vertex_property('double') numlevels = len(state.levels) rootid = tree.num_vertices() - 1 j = rootid count = 0 for i in range(numlevels-1,-1,-1): s = state.project_level(i) blocks = set(s.get_blocks().get_array()) propmap = s.get_blocks() for b in range(len(blocks)-1,-1,-1): assert inlevelblocklabels[tree.vertex(j)] == b, "b %s and inlevelblocklabels %s do not match up" % (b, inlevelblocklabels[tree.vertex(j)]) if tree.vertex(j).out_degree() == 1: treetop_label[treetop.vertex(j)] = '__PRUNEME__' dangling[treetop.vertex(j)] = False print i,b,gv.num_vertices(),'__PRUNEME__' else: gv = gt.GraphView(g, vfilt= lambda v: (propmap[v] == b) and (label[v] not in visited)) if gv.num_vertices() > 0: try: centrality_prop = centrality(gv) name, mynodeid, v, maxcentrality = getMaxCentrality(gv,centrality_prop,label,nodeid) visited.append(name) treetop_label[treetop.vertex(j)] = name dangling[treetop.vertex(j)] = False treecentrality[treetop.vertex(j)] = maxcentrality print i,b,gv.num_vertices(),name,mynodeid except: pass else: treetop_label[treetop.vertex(j)] = '__DANGLING__' dangling[treetop.vertex(j)] = True print i,b,'DANGLING' count = count + 1 j=j-1 sys.stdout.flush() treetop.vertex_properties['label'] = treetop_label treetop.vertex_properties['dangling'] = dangling treetop.vertex_properties['centrality'] = treecentrality print count,"dangling vertices\n" sys.stdout.flush() return treetop,rootid
import argparse parser = argparse.ArgumentParser(description='Select purge threshold.') parser.add_argument('threshold', metavar='N', type=str, nargs='+', 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:
plot_color[v] = g_green #red_blue_map[g.vertex_properties['value'][v]] else: plot_color[v] = (0, 0, 0, 1) #edge colors alpha = 0.15 edge_color = g.new_edge_property('vector<double>') g.edge_properties['edge_color'] = edge_color for e in g.edges(): if g.vertex_properties['vertex_name'][e.source()] == "sci-biology/samri": edge_color[e] = g_green else: edge_color[e] = g_purple state = gt.minimize_nested_blockmodel_dl(g, deg_corr=True) bstack = state.get_bstack() 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) 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])
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, )
if plot_color[e.source()] != plot_color[e.target()]: if plot_color[e.source()] == (0,0,1,1): #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, pos=pos, vertex_fill_color=g.vertex_properties['plot_color'],