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
