class DrawGraphviz: """ Draw a tree with Graphviz """ m_start: int m_end: int dot: Graph def __init__(self, save_name, start, end): self.args = args self.m_end = end self.m_start = start self.dot = Graph(name='diagram-' + save_name, strict=True) self.dot.graph_attr['rankdir'] = 'LR' self.dot.node_attr['shape'] = 'box' def __draw_func(self, node: GraphNode, parent: GraphNode or None): if node.step > self.m_end: return if node.step >= self.m_start: self.dot.node(str(id(node)), node.name) if parent is not None and node.step >= self.m_start + 1: self.dot.edge(str(id(parent)), str(id(node))) for child_node in node.child: self.__draw_func(child_node, node) def draw(self, root: GraphNode): self.__draw_func(root, None) self.dot.render(view=True, format='pdf')
def draw_graph(adjacency, name): g = Graph('G', filename=name) for node in adjacency: for Fout in adjacency[node]: #print str(node) + " " + str(Fout) g.edge(str(node), str(Fout)) g.view()
def BFSGetDist(self,v0=0): #搜索无权图其他点到 v0 的最短路径 Q = Queue() v = v0 path = [[v] for i in range(self.vexnum)] self.visited[v] = True Q.enqueue(v) while not Q.empty(): v = Q.dequeue() for w in self.arc[v]: if self.visited[w] == False: self.visited[w] = True path[w] = path[v] + [w] Q.enqueue(w) for v in range(self.vexnum): if v != v0: print(len(path[v]) - 1,end=' ') print("->".join(str(i) for i in path[v])) vg = Graph('图及其应用') with open('case1.txt') as case: n = int(case.readline()) #n 表示图中的顶点数 for i in range(n): vg.node(name=str(i),color='red') vexs = [str(i) for i in range(n)] matrix = [[0] * n for i in range(n)] edges = case.readlines() arcnum = len(edges) for edge in edges: v1,v2 = map(int, edge.split()) matrix[v1][v2] = 1 matrix[v2][v1] = 1 #无向图 vg.edge(str(v1),str(v2),color='blue') g = MGraph(vexs,matrix,arcnum) alg = ALGraph(vexs,matrix,arcnum) g.findArticul() alg.BFSGetDist(0) vg.view()
def gen_img(graph: Graph, node_num, rm_ratio: float = 0.2, root_folder='train', source_folder='', source_file='train.txt'): """ 在graph上,以rm_ratio的概率随机删除一些链路,然后用随机选取的一对节点作为源宿点,判断其是否联通。并将生成的图像放到root_folder目录中, 对应的文件名称和标签放到source_folder目录下的train.txt文件中。 """ # 生成原始数据 rds = rand_edges(graph, rm_ratio) graph.remove_edges_from(rds) src, dst = gen_src_dst(0, node_num) label = get_label(src, dst, graph) # 构造graphviz对象 name = str(time.time()) g = Graph(format='jpeg', engine='neato') g.attr('node', shape='circle') g.attr('edge') for node in graph.nodes(): g.node(name=str(node)) g.node(name=str(src), shape='triangle') g.node(name=str(dst), shape='triangle') for edge in graph.edges(): g.edge(str(edge[0]), str(edge[1])) for edge in rds: g.edge(str(edge[0]), str(edge[1]), color='white') g.render(filename=name, directory=root_folder, view=False, cleanup=True) # 存储到文件中去 file = open(os.path.join(source_folder, source_file), 'a') file.write(name + '.jpeg ' + str(label) + '\n') file.flush() file.close()
def consult_notebook(self, current_cave_id): """ Produces an svg representation of the explored portions of the cavern system along with warnings relevant to certain caves. :param: current_cave_id - where the hunter is currently located. :return: string reprsentation of svg based cavern map (using graphviz) """ tunnels = self.find_tunnels() dot = Graph(comment='Your notebook - explored caves') for mapped_cave in self.cavern_map: warning_sources = "" if mapped_cave.warnings: dot.attr('node', color='yellow') warning_sources = ",".join( [warning.source for warning in mapped_cave.warnings]) else: dot.attr('node', color='green') current_location = '*' if mapped_cave.cave.id == current_cave_id else '' dot.node(f'{mapped_cave.cave.id}', f'{mapped_cave.cave.id} {current_location}', _attributes=[('tooltip', f'{warning_sources}')]) for tunnel in tunnels: dot.attr('node', color='black') dot.edge(f'{tunnel[0]}', f'{tunnel[1]}') svg_data = dot.pipe(format='svg') return "".join(chr(datum) for datum in svg_data)
def Drawnet_notag(opt_name, tn_names, edges_info, dangling_infos, figsize=[6, 5], engine='circo', format="pdf"): ## edges_info[i] = (tn1_name,tn2_name,common_label) g = Graph(opt_name, filename=opt_name + ".gv", engine=engine, format=format) #g = Graph(engine=engine,format=format) g.attr(size='%d,%d' % (figsize[0], figsize[1])) ## insert node! g.attr('node', shape='circle') for i in tn_names: g.node(i) g.attr('node', shape='plaintext') for i in dangling_infos: g.node(i[0]) #print(edges_info) ## edges! contracted: for i in edges_info: g.edge(i[0], i[1], label="%d" % (i[2])) ## edges! non-contracted: for i in dangling_infos: g.edge(i[0], i[1]) g.view()
def visualize_countries_together_in_item(data, start_time_str=None, end_time_str=None, newspaper_str='*'): countries_together_dict = _get_countries_together_in_items(data) # print 'countries_together_dict:', countries_together_dict dot = Graph(comment='Countries together in item graph', engine='sfdp') seen_countries = set() edges_between_countries = defaultdict(int) ## Building the graph for ID_and_feed, countries in countries_together_dict.iteritems(): countries_list = list(countries) for country in countries_list: if country != '' and country not in seen_countries: dot.node(country, label=country) seen_countries.add(country) for i in xrange(len(countries)): for j in xrange(i+1, len(countries)): fst = min(countries_list[i], countries_list[j]) snd = max(countries_list[i], countries_list[j]) edges_between_countries[(fst, snd)] += 1 for edge_endpoints, edge_weight in edges_between_countries.iteritems(): dot.edge(edge_endpoints[0], edge_endpoints[1], weight=str(edge_weight)) print 'seen_countries:', seen_countries print 'edges_between_countries:', edges_between_countries dot = _apply_styles(dot, styles) # print dot.source out_dirname = newspaper_str.replace('*', '').replace('!', '').replace('[', '').replace(']', '') out_filename = ('countries_together_in_item_%s_%s.gv' % (start_time_str, end_time_str)).replace(':', '-') dot.render(os.path.join('images', out_dirname, out_filename), view=False)
def color(self): # Dict to save color color = defaultdict(list) for node in self.graph: if (len(color) == 0): color[0].append(node) continue else: for i in range(len(color)): temp = 0 for colored_node in color[i]: if (node in self.graph[colored_node]): temp = 1 break if (temp == 1): continue else: color[i].append(node) break if (node not in color[i]): color[len(color)].append(node) # Out put file output_file = Graph('Coloring graph', filename='Greedy Coloring Graph.gv',strict="True") output_file.attr( shape="circle", size='1') list_color=["red","blue", "yellow","green","gray","snow","DarkOrange1","MediumPurple1","khaki4","orchid", "cyan2", "blue violet", "GreenYellow", "HotPink", "LightGoldenrod4","DarkSeaGreen", "sienna","brown"] for i in range (len(color)): for node in color[i]: output_file.node(str(node),fillcolor=list_color[i],style="filled") for opp_node in self.graph[node]: output_file.edge(str(node),str(opp_node)) output_file.view()
def gen_graph_from_nodes(nodes, type_fail=None): graph = Graph(format='png', strict=True) graph.node_attr['fontname'] = 'Courier New' graph.edge_attr['fontname'] = 'Courier New' for node in nodes: graph.node( _type_str(node.type), '{type: %s|ast_node: %s|parent\'s type: %s}' % (_type_str(node.type), node.ast_node.as_string().replace( '<', '\\<').replace('>', '\\>') if node.ast_node else 'None', _type_str(node.parent.type) if node.parent else 'NA'), shape='record', style='rounded') for neighb, ctx_node in node.adj_list: graph.edge(_type_str(node.type), _type_str(neighb.type), label=(f' {ctx_node.as_string()}' if ctx_node else '')) if type_fail: graph.node('tf', '{TypeFail|src_node: %s}' % (type_fail.src_node.as_string().replace('<', '\\<').replace( '>', '\\>') if type_fail.src_node else 'None'), shape='record') graph.edge('tf', _type_str(type_fail.tnode1.type), style='dashed') graph.edge('tf', _type_str(type_fail.tnode2.type), style='dashed') graph.view('tnode_graph')
def render_graph(graph, name=None, directory=None, fill_infected='green3'): """ Render a user graph to an SVG file. Infected nodes are colored appropriately. Parameters: ----------- graph : UserGraph The graph to render. name : str A name for the graph. directory : str The directory to render to. fill_infected : str The fill color for infected nodes. """ dot = Graph(name=name, format='svg', strict=True) for user in graph.users(): if user.metadata.get('infected', False): dot.attr('node', style='filled', fillcolor=fill_infected) dot.node(unicode(user.tag)) dot.attr('node', style='') for user in graph.users(): for neighbor in user.neighbors: dot.edge(unicode(user.tag), unicode(neighbor.tag)) dot.render(directory=directory, cleanup=True)
def visualize(self): l = len(self.top_result) connections = dict() tags = dict() for i in range(l - 1): for j in range(1, l): if i != j: key = (i, j) message_list = self.get_message_list_between(self.top_result[i], self.top_result[j]) tag_cloud = self.subject.calculate_tag_cloud(message_list) tags[key] = self.get_top_tag_cloud(tag_cloud, 5) # DOT language dot = GraphV(comment = "Information Flow - Enron") for i in range(l): dot.node(str(i), self.top_result[i] + " - " + self.company.get_role(self.top_result[i])) for (edge, tag) in tags.iteritems(): node_1 = edge[0] node_2 = edge[1] note = ", ".join(tag) print note dot.edge(str(node_1), str(node_2), label=note) dot.render('test-output/round-table.gv', view=False)
def draw_pacs_tree_colored(log_file, out): log = pd.read_csv(log_file, header=None) log = np.array(log) n_cycles = log.shape[0] # G = Graph(format='pdf') G = Graph(format='svg') G.attr('node', shape='circle', style='filled') G.graph_attr.update(size="30") color_hex = value2hex(0) G.node('0-0', '0', fillcolor=color_hex) # G.node('0-0', '', fillcolor=color_hex, color='white', width='12') color_hex = value2hex(255 / n_cycles * 1) for i in range(len(log[0])): state = '1-' + str(i) G.node(state, str(state), fillcolor=color_hex) # G.node(state, '', fillcolor=color_hex, color='white', width='12') G.edge('0-0', state, color='black') for i in range(1, len(log) + 1): log_i = log[i - 1] color_hex = value2hex(255 / n_cycles * (i + 1)) for j, l in enumerate(log_i): state = str(i + 1) + '-' + str(j) pstate = str(i) + '-' + str(int(l)) G.node(state, str(state), fillcolor=color_hex) # G.node(state, '', fillcolor=color_hex, color='white', width='12') G.edge(pstate, state, color='black') G.render(out) make_colorbar(0, n_cycles * 5, out + '_colorbar')
def concrete_bipartite_as_graph(self, subjects, patterns) -> Graph: # pragma: no cover """Returns a :class:`graphviz.Graph` representation of this bipartite graph.""" if Graph is None: raise ImportError('The graphviz package is required to draw the graph.') bipartite = self._build_bipartite(subjects, patterns) graph = Graph() nodes_left = {} # type: Dict[TLeft, str] nodes_right = {} # type: Dict[TRight, str] node_id = 0 for (left, right), value in bipartite._edges.items(): if left not in nodes_left: subject_id, i = left name = 'node{:d}'.format(node_id) nodes_left[left] = name label = '{}, {}'.format(i, self.subjects_by_id[subject_id]) graph.node(name, label=label) node_id += 1 if right not in nodes_right: pattern, i = right name = 'node{:d}'.format(node_id) nodes_right[right] = name label = '{}, {}'.format(i, self.automaton.patterns[pattern][0]) graph.node(name, label=label) node_id += 1 edge_label = value is not True and str(value) or '' graph.edge(nodes_left[left], nodes_right[right], edge_label) return graph
def show_jointree(self): dot = Graph(strict=True) for cluster, neighbors in self.clusters.items(): dot.node(', '.join(cluster)) for neighbor in neighbors: dot.edge(', '.join(cluster), ', '.join(neighbor)) return dot
def create_interactions_graph(clauses, f): dot = GGraph(comment='Interactions graph', engine='sfdp') seen_vars = set() edges_between_vars = defaultdict(int) for clause in clauses: for lit in clause: var = f(lit) if var not in seen_vars: seen_vars.add(var) dot.node(str(var), label=str(var)) for clause in clauses: l = len(clause) for i in xrange(l): for j in xrange(i+1, l): edges_between_vars[(str(f(clause[i])), str(f(clause[j])))] += 1 for interacting_vars, weight in edges_between_vars.iteritems(): dot.edge(interacting_vars[0], interacting_vars[1], weight=str(weight)) print edges_between_vars dot = _apply_styles(dot, styles) # print dot.source dot.render(os.path.join('images', 'interactions_graph.gv'), view=True)
def display(ref, filename='temp'): """Render a tree to SVG format. *Warning:* Made for use within IPython/Jupyter only. Args: ref (Tree). filename (str): Temporary filename to store SVG output. Returns: SVG: IPython SVG wrapper object for tree. """ # Ensure all modules are available try: from graphviz import Graph from IPython.display import SVG except: raise Exception("Missing module: graphviz and/or IPython.") # Traverse tree and generate temporary Graph object output_format = 'svg' graph = Graph(filename, format=output_format) q = Queue() q.enqueue(ref) while not q.isempty(): ref = q.dequeue() graph.node(str(id(ref)), label=str(ref.key)) for child in ref.children: graph.edge(str(id(ref)), str(id(child))) q.enqueue(child) # Render to temporary file and SVG object graph.render(filename=filename, cleanup=True) return SVG(filename + '.' + output_format)
def draw_graph(graph, edges): g = Graph() for node in graph.get_nodes(): g.node(node) for edge in edges: g.edge(edge[0], edge[1], minlen='2') g.view("./grafiPDF/grafo")
def main(): p = argparse.ArgumentParser( description='This script is for generate graph figure') p.add_argument('-g', '--graph', type=str, help='path to graph csv file', required=True) p.add_argument('-o', '--out', type=str, help='output_file', required=True) option_args = p.parse_known_args()[0] path = option_args.graph out_file = option_args.out if not os.path.exists(path): print("File not found") sys.exit(1) adj_matrix = read_graph(path) g = Graph(format='png') for i in range(len(adj_matrix)): for j in range(i + 1, len(adj_matrix)): g.edge(str(i), str(j), label=str(adj_matrix[i][j])) g.render(out_file)
def get_topologie_data(self): node_data = {} for node in self.nodes: node_data[str(node.id)] = { "neighbors": node.neighbors } from graphviz import Graph graph = Graph("PLC-Topologie", filename="topologie.gv") # graph.edge(str(Node.id), str(alt_id)) tmp = [] del_list = [] for node in self.nodes: for neighbor in node.neighbors: if str(node.id) == neighbor: del_list.append(node.id) elif str(node.id) + ":" + str(neighbor) not in tmp and str(neighbor) + ":" + str(node.id) not in tmp: tmp.append(str(node.id) + ":" + str(neighbor)) graph.edge(str(node.id), str(neighbor)) for node in self.nodes: if node.id in del_list: del node.neighbors[str(node.id)] graph.view() return node_data
def graph_label(data, renewable): num_all_rows_of_state = 19 g = Graph("all_years_clustering", engine="fdp", format="svg", edge_attr={"penwidth": "4"}, node_attr={"style": "filled"}) for lab in data: if len(data[lab]) == 1: g.node(next(iter(data[lab]))) continue complete_node = [] incomplete_node = [] for state in data[lab]: dist = data[lab][state] if dist == num_all_rows_of_state: complete_node += [state] else: incomplete_node += [(state, dist)] node_color = colors.to_hex([0, 1, 0, renewable[lab]], keep_alpha=True) if len(complete_node) > 0: g.node(str(lab), label=",".join(complete_node), fillcolor=node_color) else: g.node(str(lab), label="", width=str(0.2), height=str(0.2), fillcolor=node_color) for state, dist in incomplete_node: edge_color = [0, 0, 0, dist / num_all_rows_of_state] g.edge(str(lab), state, weight=str(dist), color=colors.to_hex(edge_color, keep_alpha=True)) g.render("output/all_years_clustering", view=True, cleanup=True)
def plot(overlapping_policies): g = Graph("G", filename="Overlapping_policies", engine="sfdp") for key in overlapping_policies.keys(): for value in overlapping_policies[key]: g.edge(key, value) overlapping_policies[value].remove(key) g.view()
def json2dot(direction, color='green', view=True, DOTfileName="Metro-scheme", JSONfileName="graph.json"): src = json.load(open(JSONfileName)) dot = Graph(DOTfileName, format='png') dot.attr('node', shape='circle') for station in src["station"]: if direction != None and station in set(direction): dot.node(station, fillcolor=color, style='filled') elif station in set(src["pausing"]): dot.node(station, fillcolor='gray', style='filled') else: dot.node(station) for i in range(len(src["station"])): paths = list( filter(lambda j: (src["link"][i][j] > 0) and (j > i), range(len(src["link"][i])))) for path in paths: dot.edge(src["station"][i], src["station"][path]) return dot.render(view=view)
class render: def __init__(self,our_graph,wt_dist,colour_list,tup=[-1,-1]): self.G = Graph(format='png') self.edgeList = [] #i=0 for vertex in our_graph.vertList: self.G.node(str(vertex),label='INF' if wt_dist[vertex]==10000000 else str(wt_dist[vertex]),color='red' if colour_list[vertex] else 'black') for adjvertices in our_graph.vertList[vertex].connectedTo: if tup==[vertex,adjvertices] or tup==[adjvertices,vertex]: cl='green' else: cl='black' #print vertex.connectedTo[adjvertices] if our_graph.vertList[vertex].connectedTo[adjvertices][1] in self.edgeList: pass else: self.G.edge(str(vertex),str(adjvertices),str(our_graph.vertList[vertex].connectedTo[adjvertices][0]),color=cl) self.edgeList.append(our_graph.vertList[vertex].connectedTo[adjvertices][1]) #self.G.edge(str(vertex),str((vertex+1)%10),label='edge',color='green') self.G.view()
def vis_family_tree(self): G = Graph(format="png") num_nodes = len(self.result['states'][0]['node']) num_relations = len(self.result['relations']) for i in range(num_nodes): if i % 2 == 0: G.node(str(i), str(i), shape='square') else: G.node(str(i), str(i), shape='circle') for i in range(num_relations): G.node(str(i + num_nodes), '', shape='diamond', style='filled', height='0.1', width='0.1') for i, rel in enumerate(self.result['relations']): c, f, m = rel G.edge(str(i + num_nodes), str(c)) G.edge(str(f), str(i + num_nodes)) G.edge(str(m), str(i + num_nodes)) G.render('family-tree')
def viz(self): """ Build a dotmap for graphviz but also constructs the connected_stitch structures """ flatmap = flatten(self.stitch_map()) if self.pattern_type == 'round': dot = Graph(engine="twopi", graph_attr={ 'root': 'a1', 'overlap': 'false' }, node_attr={ 'shape': 'circle', 'margin': '0.00001 0.0001' }, format="png", name=self.name) else: dot = Graph(format="png", name=self.name) # first pass nodes for stitch in flatmap: dot.node("a" + str(stitch.id), str(stitch.stitch)) # second pass edges for stitch in flatmap: if (stitch.prev): dot.edge("a" + str(stitch.id), "a" + str(stitch.prev.id)) if (stitch.bottom): dot.edge("a" + str(stitch.id), "a" + str(stitch.bottom.id)) dot.render(view=True)
def createGraph(mi, names, graph_name): """Given dict of mutual information, print the Minimum Spanning Tree as per Chow Liu Algorithm""" milist = sorted(mi.items(), key=lambda f: np.fabs(f[1])) size = len(names) parents = -1 * np.ones(size, dtype=int) edges = [] count = 0 i = 0 while count < size - 1: verts, val = milist[i] if detect_cycle(parents, verts) == False: temp1 = verts[0] while (temp1 != -1): temp2 = parents[temp1] parents[temp1] = verts[1] temp1 = temp2 count += 1 edges.append(verts) i += 1 graph = Graph(comment='minimum spanning tree', format='png') for i in range(size): graph.node(names[i]) for j in edges: graph.edge(names[j[0]], names[j[1]]) graph.render(graph_name, view=True)
def draw(self, filename='test.gv'): """ Отрисовывает граф используя библиотеку Graphviz. Больше примеров: https://graphviz.readthedocs.io/en/stable/examples.html """ g = Graph('G', filename=filename, engine='sfdp') for v, attr in enumerate(self.attributes): if 'color' in '': g.attr('node', style='filled', fillcolor=attr['color']) if attr['color'] == 'black': g.attr('node', fontcolor='white') else: g.attr('node', style='', color='', fontcolor='', fillcolor='') if 'name' in '': g.node(str(v), label='{} ({})'.format(attr['name'], v)) else: g.node(str(v)) for i in range(self.number_of_vertices()): for j in self.adj[i]: if i < j: g.edge(str(i), str(j)) g.view()
def render_graph(): user_coords = str(request.data) user_coords = user_coords.split('&') user_latitude = float(user_coords[0][6:]) user_longitude = float(user_coords[1][5:-1]) chart_data = Graph() items = Trash.query.all() chart_data.node('U', 'USER') prev_egde_id = 'U' start_item = find_closest(items, lat=user_latitude, long=user_longitude) cl_item_id = str(start_item.id) chart_data.node(cl_item_id, cl_item_id) chart_data.edge(prev_egde_id, cl_item_id) prev_egde_id = cl_item_id while items: closest_item = find_closest(items, start_item) cl_item_id = str(closest_item.id) chart_data.node(cl_item_id, cl_item_id) chart_data.edge(prev_egde_id, cl_item_id) prev_egde_id = cl_item_id start_item = closest_item chart_output = chart_data.pipe(format='png') chart_output = base64.b64encode(chart_output).decode('utf-8') return chart_output
def graphs(file,deleted_node):#methodos gia to proairetiko meros from graphviz import Graph dot = Graph(node_attr={'color': 'lightblue2', 'style': 'filled'},format='jpg',engine='fdp') visited={} adjList=create_graph(file) deleted=False for x in adjList: visited[x]=False for key in adjList: for erased in deleted_node: if key==erased: dot.node(str(key),str(key),color='lightgrey') deleted=True if not deleted: dot.node(str(key),str(key)) deleted=False for i in adjList[key]: if not visited[i]: for erased in deleted_node:#elegxei an exoun diagraftei oi komvoi i kai key if erased==i or erased==key: deleted=True if not deleted:#den exoun diagraftei ara tous enono dot.edge(str(key),str(i)) deleted=False visited[key]=True dot.view()
def render_dungeon(dungeon: Dungeon, session_id: str, rogue_position: int): filename = f'./dungeons/d-{session_id}.gv' g = Graph('Dungeon_graph', filename=filename, format='png', engine='fdp') for room in dungeon.rooms: contains_key = any(key.room_id == room.id for key in dungeon.keys) shape = 'circle' if rogue_position == room.id: shape = 'triangle' elif contains_key: shape = 'doublecircle' elif room.id == dungeon.finish_room_id: shape = 'star' g.attr('node', color=str(room.color), shape=shape) g.node(str(room.id)) for door in dungeon.doors: if door.is_closed: style = 'dashed' else: style = 'solid' g.attr('edge', color=str(door.color), style=style) g.edge(str(door.first_room_id), str(door.second_room_id)) g.render() return f'{filename}.png'
def change_graph(self, cnt, indices, restore_flg=False): g = Graph(format='png') for nnm in self.rc_name: g.node(nnm) if restore_flg: indices = sorted(indices, reverse=True) self.graph_matrix[indices[0]][indices[1]] = 1 print('Graph Matrix : ', self.graph_matrix) for i in range(self.graph_matrix.shape[0]): for j in range(self.graph_matrix.shape[1]): if i > j and self.graph_matrix[i][j] == 1: g.edge(self.rc_name[i], self.rc_name[j]) file_name = './graph_restored_' + str( cnt) # 保存する画像のファイル名を指定(拡張子(.png)を除く) else: indices = sorted(indices, reverse=True) self.graph_matrix[indices[0]][indices[1]] = 0 print('Graph Matrix : ', self.graph_matrix) for i in range(self.graph_matrix.shape[0]): for j in range(self.graph_matrix.shape[1]): if i > j and self.graph_matrix[i][j] == 1: g.edge(self.rc_name[i], self.rc_name[j]) file_name = './graph_' + str(cnt) # 保存する画像のファイル名を指定(拡張子(.png)を除く) g.render(filename=file_name, format='png', cleanup=True, directory=None) im = Image.open(file_name + '.png') im.show()
def dump_graph(self, dot: Graph, fid=''): """Dump the subtree. """ sid = str(id(self)) dot.node(sid, str(self), shape='box') if fid: dot.edge(fid, sid)
def display_nodes(nodes): graph = Graph() for node in nodes: graph.node(node.identifier, node.name) for child in node.children: graph.edge(node.identifier, child.identifier) return graph
def visualize(self, name="graph"): """Visualize graph using 'graphviz' library. To install graphviz you can use 'pip install graphviz'. Notice that graphviz should also be installed in your system. For ubuntu, you can install it using 'sudo apt install graphviz' :param name: Name of the generated file, defaults to "graph" :type name: str, optional :raises ImportError: When unable to import graphviz. """ try: from graphviz import Graph except ImportError: msg = ("Could not import 'graphviz' module. " "Make shure 'graphviz' is installed " "or install it typing 'pip install graphviz'") raise ImportError(msg) # Create graph dot = Graph() # Create nodes for n in range(1, self.n_nodes + 1): dot.node(str(n)) # Create edges for n1, n2 in self.edges: dot.edge(str(n1), str(n2)) # Visualize dot.render(name, view=True, cleanup=True)
def plot(self, render=False, save=False, filename=None): if filename is None: filename = "decision_tree.svg" dot = Graph(name="decision_tree", filename=filename, format="svg") dot.node( str(id(self)), self.splitting_info_to_string() + "\nestimate:" + str(round(float(self.value), 3)), ) for i in range(self.depth): nodes = DecisionTree.get_level_in_list(self, i + 1) for node in nodes: if node.left_child is None: dot.node( str(id(node)), "This node is not split" + "\nestimate:" + str(round(float(node.value), 3)), ) dot.edge(str(id(node.parent)), str(id(node))) else: dot.node( str(id(node)), node.splitting_info_to_string() + "\nestimate:" + str(round(float(node.value), 3)), ) dot.edge(str(id(node.parent)), str(id(node))) if render: dot.render(view=True) if save: dot.save() return dot
def graph_draw(nodes, edges, name): g = Graph(name, format="png") for node in nodes: g.node(str(node)) for edge in edges: x = edge.split(' ')[0] y = edge.split(' ')[1] g.edge(x, y) g.view()
def plot(graph, engine='dot', filename='output/test'): """Possible engines: dot, neato, fdp, sfdp, twopi, circo""" g = Graph(format='png', engine=engine) for v in graph: g.node(str(index(v))) for v, w in graph.edges: g.edge(str(index(v)), str(index(w))) g.render(filename)
def __str__(self): A = Graph() for vertice in self.meuGrafo.nodes_iter(data=False): A.node(vertice.encode("utf8")) for aresta_A, aresta_B, dados_aresta in self.meuGrafo.edges_iter(data=True): peso_aresta = dict((chave, str(valor)) for chave, valor in dados_aresta.items()) peso_aresta['label'] = peso_aresta['weight'] del peso_aresta['weight'] A.edge(aresta_A.encode("utf8"), aresta_B.encode("utf8"), **peso_aresta) return A.source
def renderiza_grafo(self, lugar_para_gerar, nome_grafo): A = Graph(comment=nome_grafo, filename=(lugar_para_gerar + '/Grafo.gv'), engine='dot') for vertice in self.meuGrafo.nodes_iter(data=False): A.node(vertice.encode("utf8")) for aresta_A, aresta_B, dados_aresta in self.meuGrafo.edges_iter(data=True): peso_aresta = dict((chave, str(valor)) for chave, valor in dados_aresta.items()) peso_aresta['label'] = peso_aresta['weight'] del peso_aresta['weight'] A.edge(aresta_A, aresta_B, **peso_aresta) A.view()
def generateGraph(): G = Graph( engine = 'dot', filename = 'Btrfs-Graph.dot', name = 'BRTFS-Browser', comment = 'https://github.com/Zo0MER/BRTFS-Browser.git', graph_attr = {'rankdir': 'RL', 'charset':'utf-8', 'bgcolor':'#eeeeee', 'labelloc':'t', 'splines':'compound', 'nodesep':'0.7', 'ranksep':'5' }, node_attr = {'fontsize': '18.0', 'shape':'box' } ) #node with title and hyperlink on github G.node('meta', label = 'Btrfs-debug-tree \nhttps://github.com/Zo0MER/BRTFS-Browser.git', href = 'https://github.com/Zo0MER/BRTFS-Browser.git', fontcolor = '#4d2600', fontsize = '30.0' ) first = inode[0] inode.remove(inode[0]) if (inode): #link first item ROOT_TREE_DIR INODE_ITEM, INODE_REF with all INODE_ITEM EXTEND_DATA for pair in inode: G.edge(''.join([str(x) for x in first]), ''.join([str(x) for x in pair])) else: G.node(first) #save *.dot and others pathout = enterPath.get() filenameout = enterFilename.get() if (filenameout): filenameout = filenameout + '.gv.dot' else: filenameout = "btrfs-graph" G.filename = filenameout + '.gv.dot' G.directory = pathout G.save() for t in types: G.format = t G.render()
def getDot(self, color): dot = Graph(graph_attr = {'size':'3.5'}) for node in self.G: if not node in color: dot.node(node) else: dot.node(node, style = 'filled', color = color[node]) for n1 in self.G: for n2 in self.G[n1]: if n1 < n2: dot.edge(n1, n2) return dot
def plot(graph, engine='dot', filename='output/test', vertex_names={}): """ Possible engines: dot, neato, fdp, sfdp, twopi, circo Vertex_names is an optional dict from vertices to strings. """ g = Graph(format='png', engine=engine) def vertex_to_string(v): return (vertex_names[v] if v in vertex_names else '') + ' ({})'.format(str(index(v))) for v in graph: g.node(vertex_to_string(v)) for v, w in graph.edges: g.edge(vertex_to_string(v), vertex_to_string(w)) g.render(filename)
def create_conflicts_graph(clauses): dot = GGraph(comment='Conflicts graph', engine='sfdp') for i in xrange(len(clauses)): dot.node(str(i), label=str(i)) for i in xrange(len(clauses)): for j in xrange(i+1, len(clauses)): clause_i = clauses[i] clause_j = clauses[j] edge_labels = [] for lit in clause_i: if -lit in clause_j: var = abs(lit) edge_labels.append(str(var)) if len(edge_labels) > 0: dot.edge(str(i), str(j), label=','.join(edge_labels)) dot = _apply_styles(dot, styles) dot.render(os.path.join('images', 'conflicts_graph.gv'), view=True)
def render(self, filename): """ Renders the graph to a file. Args: filename (str): Filename of the map file. """ dot = Graph(comment='ISTravel graph', engine='fdp') for city in self.cities: dot.node(str(city)) ploted = [] for node in self.connections: for edge in self.connections[node]: if edge not in ploted: ploted.append(edge) dot.edge( str(edge.nodes[0]), str(edge.nodes[1]), label=edge.transport[:2] ) dot.render(filename[:filename.rfind('.')]+".gv")
def outputToPdf(graph, fileName,sourceLables): e = Graph('NYC', filename=fileName, engine='dot') e.body.extend(['rankdir=LR', 'size="100,100"']) e.attr('node', shape='ellipse') e.attr("node",color='green', style='filled') edgeExists={} for label in sourceLables: e.node(str(label)) e.attr("node",color='lightblue2', style='filled') for node in graph.nodeIter(): for edge in node.neighborsIter(): if not edge[1] in edgeExists: e.attr("edge",labelcolor="blue") e.edge(str(node.label()),edge[1],str(int(edge[0]))+"m") edgeExists[node.label()]=1 edgeExists=None e.body.append(r'label = "\nIntersections in New York City\n"') e.body.append('fontsize=100') e.view()
def visualize_topics(quora_data): dot = Graph(comment='Topics graph', engine='sfdp') seen_topics = set() for document in quora_data: question = _get_question(document) topics = document[question]['topics'] # Iterating over topics and adding nodes for topics if necessary for topic in topics: if topic not in seen_topics: dot.node(topic, label=topic) seen_topics.add(topic) # Iterating over topics and adding edges between topics belonging to the same question for i in xrange(len(topics)): for j in xrange(i+1, len(topics)): dot.edge(topics[i], topics[j]) # topic1, topic2 in product(topics, topics): # dot.edge(topic1, topic2) dot = _apply_styles(dot, styles) # print dot.source dot.render(os.path.join('images', 'topics.gv'), view=True)
def main(): source = sys.argv[1] with open(source, 'r') as infile: regions = json.load(infile) g = Graph('chroma', filename='chroma.graphview', format='png') for region in regions: name = region['name'] style = {"style": "filled"} if "owner" in region: owner = region["owner"] if owner == 0: style["color"] = "orange" else: style["color"] = "blue" style["fontcolor"] = "white" g.node(name, **style) for conn in region['connections']: g.edge(name, conn) g.render()
def save_nodes(self, filename="graph", nodes = None): print "Saving graph..." from graphviz import Graph dot = Graph(comment='Dungeon Example') if nodes == None: nodes = self.linear_nodes(self.nodes) #else: #max_appeared = appeared.values() #if max_appeared == []: start = 0 #else: start = max(max_appeared) + 1 #print start #for node in nodes: # if node.id not in appeared: # appeared[node.id] = start for node in nodes: name = node.name if hasattr(node, "replace_on_room_clear"): replace = node.replace_on_room_clear[0] name += "\n" try: name += replace.name except AttributeError: name += replace amount = 255 #60+(appeared[node.id]*64) fill = "#%02x%02xFF"%(amount, amount) #print fill shape = "oval" if node is self.entrance: shape = "box" dot.node(str(node.id), name, style="filled", fillcolor=fill, shape=shape) done_edges = [] for node in nodes: for edge in node.connections: if sorted([node.id, edge.id]) in done_edges: continue dot.edge(str(node.id), str(edge.id)) done_edges.append(sorted([node.id, edge.id])) dot.render(filename) print "Graph saved"
def rev_del(G,weights,count,Y,N): for i in range(m): gv = Graph('G', filename='rev_del',format='png') gv.node_attr.update(color='lightblue2', style='filled') gv.body.extend(['rankdir=LR']) for j in range(i+1,m): gv.edge(str(B[j][1]),str(B[j][2]),label=str(B[j][0])) for n in N: gv.edge(str(B[n[3]][1]),str(B[n[3]][2]),label=str(B[n[3]][0]),color="red") for y in Y: gv.edge(str(B[y[3]][1]),str(B[y[3]][2]),label=str(B[y[3]][0]),color="blue") gv.edge(str(B[i][1]),str(B[i][2]),label=str(B[i][0]),color="green") gv.render(str(count)) count+=1 count=Connectivity(G,weights[i],A,count,Y,N) return count
def gen_graph_from_nodes(nodes, type_fail=None): graph = Graph(format='png', strict=True) graph.node_attr['fontname'] = 'Courier New' graph.edge_attr['fontname'] = 'Courier New' for node in nodes: graph.node(_type_str(node.type), '{type: %s|ast_node: %s|parent\'s type: %s}' % (_type_str(node.type), node.ast_node.as_string().replace('<', '\\<').replace('>', '\\>') if node.ast_node else 'None', _type_str(node.parent.type) if node.parent else 'NA'), shape='record', style='rounded') for neighb, ctx_node in node.adj_list: graph.edge(_type_str(node.type), _type_str(neighb.type), label=(f' {ctx_node.as_string()}' if ctx_node else '')) if type_fail: graph.node('tf', '{TypeFail|src_node: %s}' % (type_fail.src_node.as_string().replace('<', '\\<').replace('>', '\\>') if type_fail.src_node else 'None'), shape='record') graph.edge('tf', _type_str(type_fail.tnode1.type), style='dashed') graph.edge('tf', _type_str(type_fail.tnode2.type), style='dashed') graph.view('tnode_graph')
class VisitorGraph(Visitor): """this class implement a tree visitor for our form""" def __init__(self): self.handler_dict = {Form.OperatorForm:(self.func_op_fo,{Form.D: (self.diff, {})\ , Form.Wedge: (self.wed, {}), Form.Add: (self.add,{}), \ Form.Hodge: (self.hod, {}),Form.Pullback: (self.pull, {}) }),\ Form.TerminalForm:(self.func_term_fo,{})} self.dot = Graph(comment='Tree of our form')#Digraph(comment='Tree of our form') #to store the dot for vizgraph self.edges = [] #to store the edge for the graph self.post = [] #to store the post order traversal self.pre = [] # to store the pre order traversal self.comp = 0 #to differentiate the edge #D form def diff(self, form, children=None): """function when a diff operation is made""" if form.scalar == 1: return( 'd') elif form.scalar == -1: return( "-d" ) else: return( "{}d ".format(form.scalar) ) #Wedge def wed(self, form, children=None): """function when a wedge operation is made""" if form.scalar == 1: return( '^') elif form.scalar == -1: return( "-^" ) else: return( "{}^ ".format(form.scalar) ) #Add def add(self, form, children=None): """function when a add operation is made""" if form.scalar == 1: return( '+') elif form.scalar == -1: return( "-+" ) else: return( "{}+ ".format(form.scalar) ) #Hodge def hod(self, form, children=None): """function when a hodge star operation is made""" if form.scalar == 1: return( '*') elif form.scalar == -1: return( "-*" ) else: return( "{}* ".format(form.scalar) ) #Pullback def pull(self, form, children=None): """function when a hodge star operation is made""" if form.scalar == 1: return("phi") else: return( "{}phi ".format(form.scalar) ) #TerminalForm def func_term_fo(self, form): """function that print a terminal Form""" if form.scalar == 1: return( form.name) elif form.scalar == -1: return( "-{} ".format(form.name) ) else: return( "{}{} ".format(form.scalar, form.name) ) def _visit_preorder(self, form): """the intern preorder method for visiting the tree""" if not isinstance(form,Form.TerminalForm): children=form.forms inter = self.find_method(form)(form) self.pre.append(inter) for fo in children: self._visit_preorder(fo) #in post order the find_method will be there else: inter = self.find_method(form)(form) self.pre.append(inter) def visit_preorder(self, form): """the preorder method for visiting the tree""" self.pre=[] self._visit_preorder(form) return self.pre def _visit_postorder(self, form): """the intern postorder method for visiting the tree""" if not isinstance(form,Form.TerminalForm): children=form.forms for fo in children: self._visit_postorder(fo) inter = self.find_method(form)(form) self.post.append(inter) else: inter = self.find_method(form)(form) self.post.append(inter) def visit_postorder(self, form): """the postorder method for visiting the tree""" self.post=[] self._visit_postorder(form) return self.post def _create_graph(self, form, parent_name=""): """the method for creating a graph of the tree, the edges are store inside the edges attribute""" if not isinstance(form,Form.TerminalForm): children = form.forms node = (self.find_method(form)(form)) nbr1 = str(self.comp) self.comp+=1 name = nbr1 self.dot.node(name, node) if parent_name is not "": inter=parent_name+name self.edges.append(inter) self.dot.edge(parent_name, name) parent_name=name for fo in children: self._create_graph(fo,parent_name) else: node = (self.find_method(form)(form)) nbr1 = str(self.comp) self.comp+=1 name = nbr1 #~ print(name) self.dot.node(name,node) if parent_name is not "": inter = parent_name+name self.edges.append(inter) self.dot.edge(parent_name, name) def draw_graph(self, form, name='sample'): """the method for drawing a graph of the tree, name is the file name under which we want to save it""" self.dot = Graph(comment='Tree of our form')#Digraph(comment='Tree of our form') self.edges = [] self.comp = 0 self._create_graph(form) namefile='drawing/'+name+'.gv' self.dot.render(namefile, view=True)
except: sys.stderr.write("Couldn't find appropriate links data in "+section+". Aborting.\n") for link in ibdiag_info[section][1]: # my_graph.edge(link[NodeGUID1],link[NodeGUID2]) try: the_links[tuple(sorted([link[NodeGUID1],link[NodeGUID2]]))] += 1 except: the_links[tuple(sorted([link[NodeGUID1],link[NodeGUID2]]))] = 1 the_nodes[link[NodeGUID1]][2] += 1 the_nodes[link[NodeGUID2]][2] += 1 # print(ibdiag_info[section]) nodes_list=[] for NodeGUID in the_nodes.keys(): node_graph_id, nodeDesc, link_count = the_nodes[NodeGUID] nodes_list.append((link_count, nodeDesc, node_graph_id, NodeGUID)) nodes_list.sort(reverse=True) for link_count, NodeDesc, node_graph_id, NodeGUID in nodes_list: my_graph.node(str(node_graph_id), NodeDesc) for node1, node2 in the_links: my_graph.edge(str(the_nodes[node1][0]),str(the_nodes[node2][0]), str(the_links[(node1, node2)])) #print(nodes_list) print(my_graph) #my_graph.render(filename='delme.png', view=True,format="PNG")
dot.render(view=True) ################################################ ### question c) and d) ################################################ ## Shape corresponds to those used in previous tasks g = Graph(name = 'mouse_cluster') key_list = mids.keys() ## list of mouse IDs for key in key_list: g.attr('node', color=col[class_list.index(m_class[key])], shape = shp[class_list.index(m_class[key])]) ## setting node properties based of mouse class g.node(key) ## Initialising node for x in combinations(key_list,2): if pearsonr(m_ave_values[x[0]],m_ave_values[x[1]])[0] > 0.98: ## Check for correlation score g.edge(x[0], x[1], penwidth = str(0.03/float(1-pearsonr(m_ave_values[x[0]],m_ave_values[x[1]])[0]))) ## setting up edge, if the condition satisfies, to express the correlation score g.view() ################################################ ### question e) ################################################ ## initialising graph g = Graph(name = 'Alternate Mouse Cluster') ##Initialising subgraphs based on classed c0 = Graph('cluster_0') c0.node_attr.update(color=col[0],shape =shp[0]) for key in key_list:
e.node('student') e.attr('node', shape='ellipse') e.node('name0', label='name') e.node('name1', label='name') e.node('name2', label='name') e.node('code') e.node('grade') e.node('number') e.attr('node', shape='diamond', style='filled', color='lightgrey') e.node('C-I') e.node('S-C') e.node('S-I') e.edge('name0', 'course') e.edge('code', 'course') e.edge('course', 'C-I', label='n', len='1.00') e.edge('C-I', 'institute', label='1', len='1.00') e.edge('institute', 'name1') e.edge('institute', 'S-I', label='1', len='1.00') e.edge('S-I', 'student', label='n', len='1.00') e.edge('student', 'grade') e.edge('student', 'name2') e.edge('student', 'number') e.edge('student', 'S-C', label='m', len='1.00') e.edge('S-C', 'course', label='n', len='1.00') e.attr(label=r'\n\nEntity Relation Diagram\ndrawn by NEATO') e.attr(fontsize='20')
#!/usr/bin/env python # process.py - http://www.graphviz.org/content/process from graphviz import Graph g = Graph('G', filename='process.gv', engine='sfdp') g.edge('run', 'intr') g.edge('intr', 'runbl') g.edge('runbl', 'run') g.edge('run', 'kernel') g.edge('kernel', 'zombie') g.edge('kernel', 'sleep') g.edge('kernel', 'runmem') g.edge('sleep', 'swap') g.edge('swap', 'runswap') g.edge('runswap', 'new') g.edge('runswap', 'runmem') g.edge('new', 'runmem') g.edge('sleep', 'runmem') g.view()
class Draw(Toplevel): "draw the tree to picture" def __init__(self, parent): """ @ brief initializa the Draw class @ params self -- new instance """ super(Draw, self).__init__(parent) self.transient(parent) self.title("current view") self.grab_set() def initDot(self): "init the pane" self.__dot = Graph() self.__dot.format = "gif" self.__dot.filename = "instance" self.__dot.attr('node', shape="circle") def setSource(self, source, with_label): "set the source text" self.node_suffix = 0 self.__tree = ast.literal_eval(source) if with_label: self.draw = self.__drawHasLabel else: self.draw = self.__drawNoLabel def getTree(self): "return the tree" return self.__tree def __drawNoLabel(self, tree, root="tree"): "draw the tree without label on edge" self.__dot.body.extend(["rank=same", "rankdir=TD"]) for key in tree.keys(): self.__dot.edge(root, key) if type(tree[key]) is dict: self.__drawNoLabel(tree[key], str(key)) else: node_name = str(key) + str(self.node_suffix) self.__dot.node(node_name, str(tree[key])) self.__dot.edge(str(key), node_name) self.node_suffix += 1 return self.__dot.pipe(format="gif") def __drawHasLabel(self, tree): "draw the tree with label on edge" self.__dot.body.extend(["rank=same", "rankdir=TD"]) for key in tree.keys(): if type(tree[key]) is dict: for key_ in tree[key]: if type(tree[key][key_]) is dict: child = next(iter(tree[key][key_].keys())) self.__dot.edge(key, child, str(key_)) self.__drawHasLabel(tree[key][key_]) else: node_name = str(key) + str(self.node_suffix) self.__dot.node(node_name, tree[key][key_]) self.__dot.edge(key, node_name, str(key_)) self.node_suffix += 1 return self.__dot.pipe(format="gif") def show(self): "show the image" tree = self.getTree() image = self.draw(tree) if image is not None: label_image = PhotoImage(data=base64.b64encode(image)) image_label = Label(self, image=label_image) image_label.photo = label_image else: image_label = Label(self, text="no image view") image_label.pack() self.wait_window(self)
class SNAnalyzer(object): def __init__(self,inPath,outPath,engine,analyzeType): self.network = {} self.nameIndex = {} self.inPath = inPath self.outPath = outPath self.engine = engine self.aType = analyzeType self.networkFileParse(self.inPath) def random_id(self,len): alpha = 'abcdefghijklmnopqrstuvwxyz' id = '' for i in range(0,len): id += random.choice(alpha) return id def networkFileParse(self,path): f = open(path, 'r') for line in f: line = line.replace("\n","") self.nameIndex.update({line.split(":")[0]:self.random_id(3)}) self.network.update({line.split(":")[0]:e.split(",") for e in line.split(":")[1:]}) f.close() def graphUpdate(self): if self.aType == "tw": self.graph = Digraph() elif self.aType == "fb": self.graph = Graph() else: exit("Invalid Analyze Type") for key in self.nameIndex.keys(): self.graph.node(self.nameIndex[key], key) for key in self.network.keys(): for friend in self.network[key]: if friend != "": self.graph.edge(self.nameIndex[key],self.nameIndex[friend]) def generateGraphCode(self): self.graphUpdate() return self.graph.source def renderGraph(self): self.graphUpdate() self.graph.engine = self.engine self.graph.render(self.outPath, view=True) def addNode(self,newNode): if newNode not in self.nameIndex.keys(): self.nameIndex[newNode] = self.random_id(3) self.network[newNode] = [] else: print("Error: Network already has that {} named Node !".format(newNode)) def removeNode(self,targetNode): if targetNode in self.nameIndex.keys(): del self.nameIndex[targetNode] del self.network[targetNode] for key in self.network.keys(): if targetNode in self.network[key]: self.network[key].remove(targetNode) else: print("Error: Network not has that {} named Node !".format(targetNode)) def hasRelation(self,sourceNode,targetNode): friends = self.network[sourceNode] if targetNode in friends: return True else: return False def addRelation(self,sourceNode,targetNode): if not self.hasRelation(sourceNode,targetNode): self.network[sourceNode].append(targetNode) else: print("Error: The Node {} is already related to {} !".format(sourceNode, targetNode)) def removeRelation(self,sourceNode,targetNode): if self.hasRelation(sourceNode,targetNode): self.network[sourceNode].remove(targetNode) else: print("Error: The Node {} is not related with {} !".format(sourceNode, targetNode))
def Connectivity(G,e,A,count,Y,N): #checks connectivity of graph on removing edge e if A[0][0]==e: u=A[0][1] v=A[0][2] tup=A.pop(0) index=len(B)-len(A)-1 tup.append(index) G[u-1][v-1]=G[v-1][u-1]=0 L=[] if path(G,u,v,u,L): N.append(tup) gv = Graph('G', filename='rev_del',format='png') gv.node_attr.update(color='lightblue2', style='filled') gv.body.extend(['rankdir=LR']) index=len(B)-len(A)-1 for z in range(index+1,m): gv.edge(str(B[z][1]),str(B[z][2]),label=str(B[z][0])) for n in N: gv.edge(str(B[n[3]][1]),str(B[n[3]][2]),label=str(B[n[3]][0]),color="red") for y in Y: gv.edge(str(B[y[3]][1]),str(B[y[3]][2]),label=str(B[y[3]][0]),color="blue") gv.render(str(count)) count+=1 return count else: G[u-1][v-1]=G[v-1][u-1]=e Y.append(tup) gv = Graph('G', filename='rev_del',format='png') gv.node_attr.update(color='lightblue2', style='filled') gv.body.extend(['rankdir=LR']) index=len(B)-len(A)-1 for z in range(index+1,m): gv.edge(str(B[z][1]),str(B[z][2]),label=str(B[z][0])) for n in N: gv.edge(str(B[n[3]][1]),str(B[n[3]][2]),label=str(B[n[3]][0]),color="red") for y in Y: gv.edge(str(B[y[3]][1]),str(B[y[3]][2]),label=str(B[y[3]][0]),color="blue") gv.render(str(count)) count+=1 return count
from graphviz import Graph #these are undirected import sqlite3 #open up the db, pull everything conn = sqlite3.connect('../db/prot.db') c = conn.cursor() c.execute('SELECT * from protein') proids = {x[0]:x[1] for x in c.fetchall()} c.execute('SELECT * from tags') tagids = {x[0]:x[1] for x in c.fetchall()} c.execute('SELECT * from ptag') matches = c.fetchall() graph = Graph('All protein tags', engine='neato') for key in proids: graph.node(proids[key]) for key in tagids: graph.node(tagids[key]) for x,y in matches: graph.edge(proids[x],tagids[y],len="10.0") graph.render('tag.gv') conn.close()
from slideshow import slideshow from graphviz import Graph count=1 gv = Graph('G', filename='heading',format="png") gv.node_attr.update(color='white', style='filled',fontsize="50") gv.node("Reverse Delete Algorithm") gv.render(str(count)) count+=1 gv = Graph('G', filename='Description',format="png") gv.node_attr.update(color='white', style='filled',fontsize="25") gv.edge("Start with graph G, which contains a list of edges E.","Go through E in decreasing order of edge weights.",color="white") gv.edge("Go through E in decreasing order of edge weights.","For each edge, check if deleting the edge will further disconnect the graph.",color="white") gv.edge("For each edge, check if deleting the edge will further disconnect the graph.","Perform any deletion that does not lead to additional disconnection.",color="white") gv.render(str(count)) count+=1 gv = Graph('G', filename='Legend',format="png") gv.node_attr.update(color='white', style='filled',fontsize="30") gv.body.extend(['rankdir=LR', 'size="8,5"']) gv.node("green",color="green") gv.node("red",color="red") gv.node("blue",color="blue") gv.edge("Current edge:","green",color="green") gv.edge("Deleted edge/Edge not in Spanning Tree:","red",color="red") gv.edge("Edge present in Spanning Tree:","blue",color="blue") gv.node('Legend:', shape='Mdiamond',color="yellow") gv.render(str(count)) count+=1