def sbmplot(self, state): state.draw(edge_color=gt.prop_to_size(graph.ep.weight, power=1, log=True), ecmap=(plt.cm.inferno, .6), eorder=graph.ep.weight, edge_pen_width=gt.prop_to_size(graph.ep.weight, 1, 4, power=1, log=True), edge_gradient=[])
def draw_graph(only_classified_users): g = create_graph(only_classified_users, False) pos = gt.sfdp_layout( g, vweight=g.degree_property_map('total'), eweight=g.ep.weight, groups=g.vp.group, multilevel=True, gamma=1.0, mu_p=0.2, weighted_coarse=True, coarse_method="hybrid", # mivs hybrid ec ) return gt.graph_draw( g, pos=pos, vertex_fill_color=g.vp.group, vertex_size=gt.prop_to_size(g.degree_property_map('total'), ma=20, mi=3), edge_color='white', edge_pen_width=0.1, bg_color=[0.0, 0.0, 0.0, 1.0], output_size=[800, 600], # vertex_text=g.vp.username, # vertex_font_size=8, display_props=[g.vp.group_name, g.vp.username] # output=pj(RESOURCE_DIR, 'graph.pdf'), )
def drawMST(mst, outPrefix, isolate_clustering, clustering_name, overwrite): """Plot a layout of the minimum spanning tree Args: mst (graph_tool.Graph) A minimum spanning tree outPrefix (str) Output prefix for save files isolate_clustering (dict) Dictionary of ID: cluster, used for colouring vertices clustering_name (str) Name of clustering scheme to be used for colouring overwrite (bool) Overwrite existing output files """ import graph_tool.all as gt graph1_file_name = outPrefix + "/" + os.path.basename( outPrefix) + "_mst_stress_plot.png" graph2_file_name = outPrefix + "/" + os.path.basename( outPrefix) + "_mst_cluster_plot.png" if overwrite or not os.path.isfile(graph1_file_name) or not os.path.isfile( graph2_file_name): sys.stderr.write("Drawing MST\n") pos = gt.sfdp_layout(mst) if overwrite or not os.path.isfile(graph1_file_name): deg = mst.degree_property_map("total") deg.a = 4 * (np.sqrt(deg.a) * 0.5 + 0.4) ebet = gt.betweenness(mst)[1] ebet.a /= ebet.a.max() / 50. eorder = ebet.copy() eorder.a *= -1 gt.graph_draw(mst, pos=pos, vertex_size=gt.prop_to_size(deg, mi=20, ma=50), vertex_fill_color=deg, vorder=deg, edge_color=ebet, eorder=eorder, edge_pen_width=ebet, output=graph1_file_name, output_size=(3000, 3000)) if overwrite or not os.path.isfile(graph2_file_name): cluster_fill = {} for cluster in set(isolate_clustering[clustering_name].values()): cluster_fill[cluster] = list(np.random.rand(3)) + [0.9] plot_color = mst.new_vertex_property('vector<double>') mst.vertex_properties['plot_color'] = plot_color for v in mst.vertices(): plot_color[v] = cluster_fill[ isolate_clustering[clustering_name][mst.vp.id[v]]] gt.graph_draw( mst, pos=pos, vertex_fill_color=mst.vertex_properties['plot_color'], output=graph2_file_name, output_size=(3000, 3000))
def update_state(): global time mark.a = False visited.a = False g.set_vertex_filter(None) # visit the nodes in random order vs = list(g.vertices()) shuffle(vs) for v in vs: if time - 5 < order[v] < time + 5: visited[v] = True state[v] = past elif time == order[v]: visited[v] = True mark[v] = True state[v] = present else: visited[v] = False # Filter out the recovered vertices g.set_vertex_filter(visited) size = gt.prop_to_size(g.degree_property_map("total"), ma=10) for v in vs: vsize[v] = size[v] #vsize = gt.prop_to_size(deg) gt.sfdp_layout(g, pos=pos, eweight=g.ep['weight'], groups=g.vp['comm_infomap'], max_iter=0) print(g.num_vertices()) # The following will force the re-drawing of the graph, and issue a # re-drawing of the GTK window. win.graph.fit_to_window(g=g) win.graph.regenerate_surface(reset=True) win.graph.queue_draw() # if doing an offscreen animation, dump frame to disk time += 1 if time > max_time: sys.exit(0) print(time) if offscreen: pixbuf = win.get_pixbuf() strdate = (initial_date + timedelta(days=time)).strftime('%d-%m-%Y') pixbuf = put_text(pixbuf, strdate, 0, 10) pixbuf.savev(dir + '/news-date_%06d.png' % time, 'png', [], []) # We need to return True so that the main loop will call this function more # than once. print('-' * 80) return True
def show(): g = gt.load_graph(filename) kwargs = {} print 'Graph loaded, now drawing to %s' % imagename if 'blocks' in g.vp: kwargs['vertex_fill_color'] = g.vertex_properties['blocks'] if 'rank' in g.vp: kwargs['vertex_size'] = gt.prop_to_size(g.vp['rank'], mi=5, ma=15) if 'pos' in g.vp: kwargs['pos'] = g.vp['pos'] gt.graph_draw(g, vertex_shape=g.vp['rc'], output=imagename, **kwargs)
def save_graph(self, graph_path): gt.graph_draw(self.graph, vertex_text=self.graph_vertex_label, pos=self.graph_position, vertex_font_size=18, edge_pen_width=gt.prop_to_size(self.graph_penalty, mi=0, ma=8, power=1), vertex_fill_color=self.graph_vertex_color, edge_color=self.graph_edge_color, output_size=(self.w * 50, self.h * 50), output=graph_path)
def plot(G_gt, layout_gt, n_range, palette, **kwargs): # pylint: disable=unused-argument v_text = G_gt.vertex_properties['id'] # v_degrees_p = G_gt.degree_property_map('out') # v_degrees_p.a = np.sqrt(v_degrees_p.a)+2 v_degrees_p = G_gt.vertex_properties['degree'] v_size_p = gt.prop_to_size(v_degrees_p, n_range[0], n_range[1]) v_fill_color = G_gt.vertex_properties['fill_color'] e_weights = G_gt.edge_properties['weight'] e_size_p = gt.prop_to_size(e_weights, 1.0, 4.0) # state = gt.minimize_blockmodel_dl(G_gt) # state.draw( # c = gt.all.closeness(G_gt) v_blocks = gt.minimize_blockmodel_dl(G_gt).get_blocks() plot_color = G_gt.new_vertex_property('vector<double>') G_gt.vertex_properties['plot_color'] = plot_color for v_i, v in enumerate(G_gt.vertices()): scolor = palette[v_blocks[v_i]] plot_color[v] = tuple(int(scolor[i : i + 2], 16) for i in (1, 3, 5)) + (1,) gt_draw.graph_draw( G_gt, # vorder=c, pos=layout_gt, output_size=(1000, 1000), # vertex_text_offset=[-1,1], vertex_text_position=0.0, vertex_text=v_text, vertex_color=[1, 1, 1, 0], vertex_fill_color=v_fill_color, vertex_size=v_size_p, vertex_font_family='helvetica', vertex_text_color='black', edge_pen_width=e_size_p, inline=True, )
def draw_frames(glist): stamp = datetime.strftime(datetime.now(), "%d_%h-%H-%M") outpath = f"./outputs_{stamp}" if not os.path.exists(outpath): os.mkdir(outpath) for i, gu in enumerate(glist): gt.graph_draw( gu, pos=gu.vp.pos, vertex_fill_color=gu.vp.lum, edge_pen_width=0.2, vertex_size=gt.prop_to_size(gu.vp.mass, mi=2, ma=10, log=False, power=2), output=os.path.join(outpath, "frame%06d.png" % i), adjust_aspect=False )
def test1(): gt.seed_rng(42) seed(42) NUMBER_OF_NODES = 20 points = random((NUMBER_OF_NODES, 2)) points[0] = [0, 0] points[1] = [1, 1] g, pos = gt.triangulation(points, type="delaunay") g.set_directed(True) edges = list(g.edges()) # reciprocate edges for e in edges: g.add_edge(e.target(), e.source()) # The capacity will be defined as the inverse euclidean distance cap = g.new_edge_property("double") for e in g.edges(): cap[e] = min(1.0 / norm(pos[e.target()].a - pos[e.source()].a), 10) g.edge_properties["cap"] = cap g.vertex_properties["pos"] = pos g.save("flow-example.xml.gz") gt.graph_draw(g, pos=pos, edge_pen_width=gt.prop_to_size(cap, mi=0, ma=3, power=1), output="flow-example.pdf")
'''#seed_number = randint(1, 1000) # generator = Random(10, 40, directed=True, seed_number=seed_number) seed_number = 386 generator = Triangulation(50, type="delaunay", directed=True, seed_number=seed_number) # generator = Wikipedia() g, source, target = generator.generate() print("Source: " + str(source) + " target " + str(target)) gt.graph_draw(g, edge_pen_width=gt.prop_to_size(g.ep.cap, mi=1, ma=5, power=1), output="cf/cf_capacities.pdf", vertex_text=g.vertex_index, edge_text=g.ep.cap)''' #seed_number = randint(1, 1000) seed_number = 14 generator = Triangulation(50, type="delaunay", directed=True, seed_number=seed_number) g, source, target = generator.generate() gt.graph_draw(g, edge_pen_width=gt.prop_to_size(g.ep.cap, mi=1, ma=5, power=1), output="cf/cf_capacities.pdf", vertex_text=g.vertex_index, edge_text=g.ep.cap) # source = g.vertex(0) # target = g.vertex(3) solver = Goldberg(g) solution = solver.get_max_flow(source, target) print("Il max flow trovato da Golberg รจ:", solution) labels = g.new_vertex_property("string") for vertex in g.vertices(): labels[vertex] = str(g.vertex_index[vertex]) + "(" + str(g.vp.height[vertex]) + "," + str( g.vp.excess[vertex]) + ")" gt.graph_draw(g, edge_pen_width=gt.prop_to_size(g.ep.residual, mi=1, ma=5, power=1), output="cf/max-flow-our-solution.pdf", vertex_text=labels, edge_text=g.ep.residual)
def run_analysis(netfile, compnet_files): ''' Run the analysis. :param netfile: Filename of the network to analyze :param compnet_files: List of filenames of the comparison networks, viz., the high-energy physics networks. ''' # Timestamp # -------------------- print(datetime.now()) # Load the network # -------------------- net, outfile_pre, core_pmap, core_vertices = load_net(netfile + '.graphml', core = True, filter = True) output_folder = 'output/' outfile_pre = output_folder + outfile_pre # Plotting print('Plotting') layout = layout_and_plot(net, core_pmap, outfile_pre) # Store the layout in the net net.vp['layout'] = layout # Show only the core vertices net.set_vertex_filter(core_pmap) layout_and_plot(net, core_pmap, outfile_pre, filename_mod = '.core.net', reverse_colors = True) net.set_vertex_filter(None) # Vertex statistics # -------------------- # ECDF for out-degree distribution degree_dist(net, core_vertices, outfile = outfile_pre, show_plot = False, save_plot = True) # ECDF for eigenvector centrality ## Currently this is causing a segmentation fault # ev_centrality_dist(net, core_vertices, outfile = outfile_pre, # show_plot = False, save_plot = True) # Modularity # -------------------- # Calculate modularity, using the core vertices as the partition modularity = gtcomm.modularity(net, core_pmap) print('Observed modularity: ' + str(modularity)) obs_ins = insularity(net, core_pmap) print('Observed insularity: ' + str(obs_ins)) # Calculate the number of core vertices n_core = len(core_vertices) # Construct a sampling distribution for the modularity statistic # And use it to calculate a p-value for the modularity print('Random sample modularity') modularity_sample_dist(net, n_core, modularity, outfile = outfile_pre + '.mod', show_plot = False, save_plot = True) print('Random sample insularities') modularity_sample_dist(net, n_core, obs_ins, mod_func = insularity, outfile = outfile_pre + '.ins', show_plot = False, save_plot = True) # Information-theoretic partitioning print('Information-theoretic partitioning') # Calculate the partition gt.seed_rng(5678) np.random.seed(5678) part_block = gt.minimize_blockmodel_dl(net, B_min = 2, B_max = 2, verbose = True, overlap = False) # Extract the block memberships as a pmap net.vp['partition'] = part_block.get_blocks() # Calculate the modularity block_modularity = gtcomm.modularity(net, net.vp['partition']) print('Partion modularity: ' + str(block_modularity)) print('Partition insularities') block_insularities = partition_insularity(net, net.vp['partition']) for community in block_insularities: print('Community ' + str(community) + ': ' + str(block_insularities[community])) print('Plotting') size_pmap = gt.prop_to_size(core_pmap, mi = 10, ma = 20) layout_and_plot(net, net.vp['partition'], outfile_pre, size_pmap = size_pmap, filename_mod = '.partition') # Modularity optimization optimal_sample_dist(net, modularity, obs_ins, outfile = outfile_pre, show_plot = False, save_plot = True) # Save results # -------------------- # The above covers all of the analysis to be written into the output files, # so we'll go ahead and save things now. print('Saving') # Save in graph-tool's binary format net.save(outfile_pre + '.out' + '.gt') # Replace vector-type properties with strings #net.list_properties() properties = net.vertex_properties for property_key in properties.keys(): property = properties[property_key] if 'vector' in property.value_type(): properties[property_key] = property.copy(value_type = 'string') # Save as graphml net.save(outfile_pre + '.out' + '.graphml') # Comparison networks # -------------------- for compnet_file in compnet_files: # Load the comparison network compnet, compnet_outfile = load_net(compnet_file) # Set it to the same directedness as the network of interest compnet.set_directed(net.is_directed()) # Size of compnet n_compnet = compnet.num_vertices() # Num vertices in compnet to use in each random partition k_compnet = round(n_core / net.num_vertices() * n_compnet) # Sample distribution based on random partition print('Random sample modularities') print('Observed modularity: ' + str(modularity)) modularity_sample_dist(compnet, k_compnet, modularity, outfile = outfile_pre + '.mod.' + compnet_outfile, show_plot = False, save_plot = True) print('Random sample insularities') print('Observed insularity: ' + str(obs_ins)) modularity_sample_dist(compnet, k_compnet, obs_ins, mod_func = insularity, outfile = outfile_pre + '.ins.' + compnet_outfile, show_plot = False, save_plot = True) # Sample distribution based on optimizing modularity # optimal_sample_dist(compnet, modularity, n_samples = 300, # outfile = outfile_pre + '.mod.' + compnet_outfile, # show_plot = False) # Timestamp # -------------------- print(datetime.now()) # Visually separate analyses print('-'*40)
def create_graph(filename, author): """Get entity graph data from file and create graph with networkx.""" # Get filename (of array) and load with open(DIRECTORY+filename,'rb') as f: entity_graph = pickle.load(f, encoding='latin1') # Compute entity graph sum to verify graph is not empty. eg_sum = np.sum(entity_graph) # Discard empty graphs if eg_sum==0.0: return None ## Get graphs (add empty vertex) entity_graph_zero = np.zeros((entity_graph.shape[0]+1, entity_graph.shape[1]+1)) entity_graph_zero[:-1,:-1] = entity_graph #adj_matrix = entity_graph_zero # Get adjacency matrix adj_matrix = entity_graph # Get circular graph pos D = nx.from_numpy_matrix(entity_graph_zero) pos_x = nx.shell_layout(D) # Create graph, set nodes, edge type and pos g = gt.Graph(directed = True) g.add_vertex(adj_matrix.shape[0]) edge_weights = g.new_edge_property("float") pos = g.new_vertex_property("vector<float>") v_count = g.new_vertex_property("int") # Assign pos by network x n_vertices = adj_matrix.shape[0] for i in range(adj_matrix.shape[0]): vert = n_vertices-i pos[g.vertex(i)] = pos_x[vert] v_count[g.vertex(i)] = i+1 # Fill graph with weights for i in range(n_vertices): for j in range(n_vertices): if adj_matrix[i,j] != 0.0: e = g.add_edge(i,j) edge_weights[e] = adj_matrix[i,j] # Prop sizing v_size_p = gt.prop_to_size(v_count, 5,10) edge_weights_p = gt.prop_to_size(edge_weights, mi=0, ma=10, power=1) # Save edge/vertex properties g.edge_properties["weights"] = edge_weights g.vertex_properties["pos"] = pos g.vertex_properties["v_count"] = v_count # Print graph #gt.graph_draw(g, pos=pos,vertex_text=v_count, vertex_fill_color='orange', edge_pen_width=edge_weights_p, output_size=(600, 600)) # Generate Graph try: new_graph = Graph(g, author, filename, entity_graph) except ValueError: print("This file didn't work:", filename) return return new_graph
mass -= min(mass) mass /= max(mass) ## # applying properties for i, v in enumerate(g.vertices()): g.vp.mass[v] = mass[i] g.vp.lum[v] = lum[i] g.vp.mag[v] = mag[i] g.vp.pos[v] = np.array([mag[i], -lum[i]]) ## gtdraw = gt.graph_draw( g, pos=g.vp.pos, vertex_fill_color=g.vp.lum, vertex_size=gt.prop_to_size(g.vp.mass, mi=3, ma=9.5, log=False, power=2), output=os.path.join(outpath, "HR_diag.png"), ) ## posv = g.vp.pos.get_2d_array([0, 1]).T ## gg, gpos = gt.geometric_graph(posv, ibin) ## gu = gt.graph_union(gg, g, intersection=g.vertex_index, internal_props=True) ## gt.graph_draw( gu, pos=gu.vp.pos, vertex_fill_color=gu.vp.lum, vertex_size=gt.prop_to_size(gu.vp.mass, mi=2, ma=10, log=False, power=2), output=os.path.join(outpath, f"HR_diag_edges_{ibin}.png"),
log=True, ) plt.xticks(np.linspace(0, 0.6, 13), rotation=45, fontsize=6) #plt.title('Histogram of Closeness Centrality\nLargest Component') plt.xlabel('Closeness Centrality') plt.ylabel('Frequency (log)') plt.savefig("closeness_hist_g_friend_LC_ap1.png") plt.close() if descClosePlot_bool == True: # Screenshot added to Github (less loading time) gt.graph_draw(g_friend_LC, pos=None, vertex_fill_color=vprop_closeness, vertex_size=gt.prop_to_size(vprop_closeness, mi=5, ma=15), vcmap=plt.cm.gist_heat, vorder=vprop_closeness, output="closeness_g_friend_LC_ap1.pdf") #-- Betweenness Distribution of Largest Component --# if descBetw_bool == True: print("\n\n#-- Betweenness Distribution --#\n") vprop_betweenness, eprop_betweenness = gt.betweenness(g_friend_LC) g_friend_LC.vp.v_betweenness = vprop_betweenness g_friend_LC.ep.e_betweenness = eprop_betweenness v_between_array = np.array(vprop_betweenness.a)
state[v] = past elif time == order[v]: visited[v] = True mark[v] = True state[v] = present else: visited[v] = False # Filter out the recovered vertices max_time = np.max(list(order)) g.set_vertex_filter(visited) print('asdasd', g.num_vertices()) vsize = g.new_vertex_property("double") deg = g.degree_property_map("total") vsize = gt.prop_to_size(g.degree_property_map("total")) pos = gt.sfdp_layout(g, eweight=g.ep['weight'], groups=g.vp['comm_infomap'], init_step=0.005, max_iter=1) if not offscreen: win = gt.GraphWindow(g, pos, geometry=(500, 400), edge_color=[0.6, 0.6, 0.6, 1], vorder=visited, vertex_size=vsize, vertex_fill_color=g.vp['comm_infomap'], vertex_halo=mark, vertex_halo_color=[0.8, 0, 0, 0.6])
args = argparser.parse_args() g = gt.load_graph(args.file) g = gt.GraphView(g, vfilt=gt.label_largest_component(g), directed=False) g = gt.Graph(g, prune=True) filename = 'degree' # chequea que todo sea como "debe ser" print('chequeando...', args.file) print('vertices', g.num_vertices()) # numero de vertices print('edges', g.num_edges()) # numero de links weight = g.ep['weight'] width = gt.prop_to_size(weight, ma=.5) # seteo de algunas argumentos de la creacion del grafo pos = g.vp['pos_sfdp_infomap'] deg = g.degree_property_map("total", weight=weight) vsize = gt.prop_to_size(deg) vorder = -vsize.a df = pd.DataFrame({'node': list(g.vertices()), 'degree': list(deg)}) df.sort_values(by='degree', inplace=True, ascending=False) print(df.head(15)) print('drawing...') # dibuja el grafico en el archivo filename.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)
# plot graph (like plot2Dnet) # pos=g.vp.locs #pos = gt.planar_layout(g) #radial_tree_layout(g, 0) #arf_layout(g) # fruchterman_reingold_layout(g) plotGraph = 0 if plotGraph: print('Plotting node and edges graph...') gt.graph_draw(g, pos=g.vp.locs, vertex_text=g.vertex_index, vertex_size=5, vertex_fill_color=pop_ids, vcmap=matplotlib.cm.jet, vcnorm=1, edge_color=g.ep.weights, ecmap=(matplotlib.cm.jet, .6), edge_pen_width=gt.prop_to_size(g.ep.weights, 0.05, 0.1, power=1), vertex_font_size=5, output_size=(100, 1000), output=outputFile + '_graph.pdf') # caculate betweeness # bv, be = betweenness(g) print(' elapsed time: %d s' % (time() - start)) # -------------------------------------------------------------------------- # run inference SBM algorithm to extract groupings # -------------------------------------------------------------------------- if loadState: print('Loading the nested stochastic block model...')
for v in g.vertices(): state[v] = future d, m, y = map(int, g.vp['date'][v].split('-')) vdate = date(y, m, d) order[v] = (vdate - initial_date).days # Newly infected nodes will be highlighted in red mark = g.new_vertex_property("bool") visited = g.new_vertex_property("bool") mark.a = False visited.a = False # This creates a GTK+ window with the initial graph layout time = -1 max_time = np.max(list(order)) width = gt.prop_to_size(g.ep['weight'], ma=.1) if not offscreen: win = gt.GraphWindow(g, pos, geometry=(500, 400), edge_color=[0.6, 0.6, 0.6, 1], vorder=visited, vertex_fill_color=state, vertex_halo=mark, vertex_halo_color=[0.8, 0, 0, 0.6]) print('asdasd', g.num_vertices()) else: win = Gtk.OffscreenWindow() win.set_default_size(500, 400) win.graph = gt.GraphWidget(g, pos,
for v in cs.get_vertices(): cs.vp.name[v] = names[v] cs.vp.color[v] = "green" if price_change[v] >= 0 else "red" cs.vp.volmcap[v] = volmcap[v] cs.vp.pricec[v] = price_change[v] cs.vp.mcapc[v] = mcap_change[v] cs.vp.mcap[v] = mcap[v] print(names[v], volmcap[v], price_change[v]) # %% cs.vp.name[1] cs.vp.color[1] cs.vp.volmcap[1] # %% gt.graph_draw( cs, vertex_text=cs.vp.name, vertex_text_position="centered", vertex_font_size=8, vertex_fill_color=cs.vp.color, vertex_size=gt.prop_to_size(cs.vp.mcap, mi=5, ma=15, power=1, log=True), output = "market_graph.png", ) # %%
import numpy as np import math from generation.Triangulation import Triangulation # Number of nodes N = 5 # Number of edges M = 10 seed_number = 45 generator = Triangulation(N, directed=False, seed_number=seed_number) g, src, tgt = generator.generate() cap = g.ep.cap gt.graph_draw(g, edge_pen_width=gt.prop_to_size(cap, mi=1, ma=1, power=1), output="graph_to_solve.pdf", vertex_text=g.vertex_index, edge_text=g.ep.cap) # using GraphTool algorithm, find the solution to test and print the resulting graph res = gt.push_relabel_max_flow(g, src, tgt, cap) res.a = cap.a - res.a # the actual flow max_flow = sum(res[e] for e in tgt.in_edges()) print("Il max flow trovato da GraphTool รจ:", max_flow) labels = g.new_edge_property("string") for edge in g.edges(): labels[edge] = str(res[edge]) + "/" + str(cap[edge]) gt.graph_draw(g, edge_pen_width=gt.prop_to_size(res, mi=1, ma=5, power=1),
import graph_tool.all as gtool gr = gtool.collection.data["polblogs"] gr = gtool.GraphView(gr, vfilt=gtool.label_largest_component(gr)) cness = gtool.closeness(gr) gtool.graph_draw(gr, pos=gr.vp["pos"], vertex_fill_color=cness, vertex_size=gtool.prop_to_size(cness, mi=5, ma=15), vorder=cness, vcmap=matplotlib.cm.gist_heat, output="political_closeness.pdf")
print('start drawing') pos_fr = gt.fruchterman_reingold_layout(g, n_iter=1000) g.vertex_properties["pos_fr"] = pos_fr control = g.new_edge_property("vector<double>") for e in g.edges(): d = sqrt(sum((pos_fr[e.source()].a - pos_fr[e.target()].a)**2)) / 5 control[e] = [0.3, d, 0.7, d] g.edge_properties["control"] = control gt.graph_draw(g, pos=pos_fr, vertex_pen_width=0.6, vertex_color=[1, 1, 1, 1], vertex_fill_color=color_bytype, vertex_size=gt.prop_to_size(degrees, mi=10, ma=20), edge_color=edge_color, edge_control_points=control, edge_pen_width=edge_width, output_size=(800, 800), output="Graphs/Component2995nodes_fr.svg") pos_rt = gt.radial_tree_layout(g, g.vertex(0)) for e in g.edges(): d = sqrt(sum((pos_rt[e.source()].a - pos_rt[e.target()].a)**2)) / 5 control[e] = [0.3, d, 0.7, d] gt.graph_draw(g, pos=pos_rt, vertex_pen_width=0.6, vertex_color=[1, 1, 1, 1], vertex_fill_color=color_bytype,
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)
## ## # offscreen = sys.argv[1] == "offscreen" if len(sys.argv) > 1 else False # This creates a GTK+ window with the initial graph layout if not offscreen: win = gt.GraphWindow( ug, pos, geometry=(800, 800), vertex_fill_color=ug.vp.lum, vertex_size=gt.prop_to_size(ug.vp.mass, mi=2, ma=10, log=False, power=2), ) else: win = Gtk.OffscreenWindow() win.set_default_size(800, 800) win.graph = gt.GraphWidget( ug, pos, vertex_fill_color=ug.vp.lum, vertex_size=gt.prop_to_size(ug.vp.mass, mi=2, ma=10, log=False, power=2),
company_count = len(comp_comp_tri) for i in range(0, company_count): v_company[v.next()] = comp_tag_table.index[i] g.vertex_properties['company'] = v_company for i in range(0, len(comp_comp_tri)): for j in range (0, len(comp_comp_tri)): if i != j and comp_comp_tri [i,j] > 0: e = g.add_edge(g.vertex(i), g.vertex(j)) e_weight[e] = comp_comp_tri[i,j] g.edge_properties['weight'] = e_weight # to filter the graph a bit v_bet, e_bet = gt.betweenness(g, weight=g.edge_properties['weight']) pos, it = gt.graph_draw(g, vertex_fill_color = v_bet, vertex_size = gt.prop_to_size(v_bet, mi=2, ma=15), edge_pen_width = gt.prop_to_size(e_bet, mi=0.3, ma = 5)) # could use degree to filter deg = g.degree_property_map(deg='total', weight = g.edge_properties['weight']) companies_list = comp_tag_table.index companies_list[deg.a.argmax()] v_bet, e_bet = gt.betweenness(g, weight = g.edge_properties['weight']) companies_list[v_bet.a.argmax()]