def main(root, title=''):
net = ReadNetwork(root) # from Networks folder
#print "Writing dot..."
write_dot(net, '{}/MeTeOR{}.dot'.format(root, title))
#write_dot(nonNormnet,'{}/MeTeOR_nonNorm{}.dot'.format(root,title))
render(root, title)
def main():
device_dict = device_to_dict(node)
static_device_set = get_static_devic_set(device_dict)
device_list = read_device_without_noise(static_device_set)
dict = connectivity_at_certain_time(time_switch(int(sys.argv[1])), device_list, node);
G = dict_to_graph(dict)
write_dot(G, 'graph.dot')
def extract_forward_slice(self, slice_root_node, function_name):
slice_graph = nx.ego_graph(self.simplified_pdg_graph,
slice_root_node,
radius=100000)
forward_slice_graph = nx.DiGraph()
forward_slice_graph.add_nodes_from(slice_graph.nodes(data=True))
forward_slice_graph.add_weighted_edges_from(slice_graph.edges)
slice_name = function_name + '_{}'.format(
self.slice_root_nodes[slice_root_node])
slice_file = self.add_dependency_prefix(slice_name + '.fs.dot')
write_dot(forward_slice_graph, slice_file)
# elapsed_time = default_timer() - self.start_time
# write_file(self.fs_time_file.format(slice_name), '{}'.format(elapsed_time))
# self.start_time = default_timer()
self.get_abstract_slice(forward_slice_graph, slice_root_node,
function_name,
self.slice_root_nodes[slice_root_node])
elapsed_time = default_timer() - self.start_time
afs_time_file = join_path(self.pdg_path,
'{}.afs.time.txt'.format(slice_name))
write_file(afs_time_file, '{}'.format(elapsed_time))
# self.render_pdf_graph(slice_file)
return forward_slice_graph, slice_file, slice_name
def draw_graph(stacks):
import networkx as nx
import matplotlib.pyplot as plt
from networkx.drawing.nx_agraph import write_dot, graphviz_layout
G = nx.DiGraph()
for l in stacks:
reductions = l.split("->")
for i, k in zip(reductions, reductions[1:]):
G.add_edge(k.replace("cb_explore_adf_", ""),
i.replace("cb_explore_adf_", ""))
if len(reductions) == 1:
G.add_node(reductions[0])
plt.figure(num=None,
figsize=(24, 12),
dpi=120,
facecolor='w',
edgecolor='k')
write_dot(G, 'graphviz_format.dot')
pos = graphviz_layout(
G,
prog='dot',
args='-Nfontsize=10 -Nwidth=".2" -Nheight=".2" -Nmargin=0 -Gfontsize=12'
)
nx.draw(G, pos, with_labels=True, arrows=True, node_size=1600)
plt.savefig('reduction_graph.png')
def draw_graph(nodes, edges, graphs_dir, default_lang='all'):
lang_graph = nx.MultiDiGraph()
lang_graph.add_nodes_from(nodes)
for edge in edges:
if edges[edge] == 0:
lang_graph.add_edge(edge[0], edge[1])
else:
lang_graph.add_edge(edge[0], edge[1], weight=float(edges[edge]), label=str(edges[edge]))
# print graph info in stdout
# degree centrality
print('-----------------\n\n')
print(default_lang)
print(nx.info(lang_graph))
try:
# When ties are associated to some positive aspects such as friendship or collaboration,
# indegree is often interpreted as a form of popularity, and outdegree as gregariousness.
DC = nx.degree_centrality(lang_graph)
max_dc = max(DC.values())
max_dc_list = [item for item in DC.items() if item[1] == max_dc]
except ZeroDivisionError:
max_dc_list = []
# https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BC%D0%BF%D0%BB%D0%B5%D0%BA%D1%81%D0%BD%D1%8B%D0%B5_%D1%81%D0%B5%D1%82%D0%B8
print('maxdc', str(max_dc_list), sep=': ')
# assortativity coef
AC = nx.degree_assortativity_coefficient(lang_graph)
print('AC', str(AC), sep=': ')
# connectivity
print("Слабо-связный граф: ", nx.is_weakly_connected(lang_graph))
print("количество слабосвязанных компонент: ", nx.number_weakly_connected_components(lang_graph))
print("Сильно-связный граф: ", nx.is_strongly_connected(lang_graph))
print("количество сильносвязанных компонент: ", nx.number_strongly_connected_components(lang_graph))
print("рекурсивные? компоненты: ", nx.number_attracting_components(lang_graph))
print("число вершинной связности: ", nx.node_connectivity(lang_graph))
print("число рёберной связности: ", nx.edge_connectivity(lang_graph))
# other info
print("average degree connectivity: ", nx.average_degree_connectivity(lang_graph))
print("average neighbor degree: ", sorted(nx.average_neighbor_degree(lang_graph).items(),
key=itemgetter(1), reverse=True))
# best for small graphs, and our graphs are pretty small
print("pagerank: ", sorted(nx.pagerank_numpy(lang_graph).items(), key=itemgetter(1), reverse=True))
plt.figure(figsize=(16.0, 9.0), dpi=80)
plt.axis('off')
pos = graphviz_layout(lang_graph)
nx.draw_networkx_edges(lang_graph, pos, alpha=0.5, arrows=True)
nx.draw_networkx(lang_graph, pos, node_size=1000, font_size=12, with_labels=True, node_color='green')
nx.draw_networkx_edge_labels(lang_graph, pos, edges)
# saving file to draw it with dot-graphviz
# changing overall graph view, default is top-bottom
lang_graph.graph['graph'] = {'rankdir': 'LR'}
# marking with blue nodes with maximum degree centrality
for max_dc_node in max_dc_list:
lang_graph.node[max_dc_node[0]]['fontcolor'] = 'blue'
write_dot(lang_graph, os.path.join(graphs_dir, default_lang + '_links.dot'))
# plt.show()
plt.savefig(os.path.join(graphs_dir, 'python_' + default_lang + '_graph.png'), dpi=100)
plt.close()
def select_graph(graph_file_name):
global INPUT_FOLDER, G, graph_name, all_pairs_sp
GRAPH_PATH = INPUT_FOLDER + graph_file_name
input_file_name = os.path.basename(GRAPH_PATH)
graph_name = input_file_name.split(".")[0]
print(graph_name)
# Reading the graphs
G = nx_read_dot(GRAPH_PATH) #this should be the default structure
#if not nx.is_connected(G):
# print('The graph is disconnected')
# quit()
# convert ids to integers
G = nx.convert_node_labels_to_integers(G)
# Set zero coordinates for all vertices
for i in nx.nodes(G):
x = random.uniform(0, 1)
y = random.uniform(0, 1)
#if i==0: x, y = 0, 0
#if i==1: x, y = 1, 1
#if i==2: x, y = 0, 1
#if i==3: x, y = 1, 0
curr_pos = str(x) + "," + str(y)
nx.set_node_attributes(G, {i: curr_pos}, "pos")
G = scale_graph(G, 100)
write_dot(G, OUTPUT_FOLDER + graph_name + '_initial.dot')
G = scale_graph(G, 1 / 100)
all_pairs_sp = None
def gen_strings_network(metadata_file, output_file, threshold):
malware_data = pandas.read_csv(metadata_file, dtype=str, keep_default_na=False, skipinitialspace=True)
malware_paths = malware_data['FILE'] # where we'll store the malware file paths
malware_attributes = dict() # where we'll store the malware strings
graph = networkx.Graph() # the similarity graph
# filter out any paths that aren't PE files
malware_paths = filter(pecheck, malware_paths)
# get and store the strings for all of the malware PE files
for path in malware_paths:
attributes = getstrings(path)
print("Extracted {0} attributes from {1} ...".format(len(attributes),path))
malware_attributes[hashlib.sha256(open(path, 'rb').read()).hexdigest()] = attributes
# add each malware file to the graph
graph.add_node(path,label=hashlib.sha256(open(path, 'rb').read()).hexdigest()[:10])
# iterate through all pairs of malware
for malware1,malware2 in itertools.combinations(malware_paths,2):
# compute the jaccard distance for the current pair
jaccard_index = jaccard(malware_attributes[hashlib.sha256(open(malware1, 'rb').read()).hexdigest()],malware_attributes[hashlib.sha256(open(malware2, 'rb').read()).hexdigest()])
# if the jaccard distance is above the threshold add an edge
if jaccard_index > threshold:
print(malware1,malware2,jaccard_index)
graph.add_edge(malware1,malware2)
# graph.add_edge(malware1,malware2,penwidth=1+(jaccard_index-threshold)*10)
# write the graph to disk so we can visualize it
write_dot(graph, output_file)
def main():
keyword, number = get_arguments()
g = nx.DiGraph()
api = twitter.Api(
consumer_key=consumer_key,
consumer_secret=consumer_secret,
access_token_key=access_token_key,
access_token_secret=access_token_secret,
)
tweets = []
while len(tweets) < number:
max_id = "" if len(tweets) == 0 else ("&max_id=" + tweets[-1].id_str)
count = "&count=100"
query = "q=" + keyword + count + max_id
next_tweets = api.GetSearch(raw_query=query)
if len(tweets) != 0 and tweets[-1].id_str == next_tweets[0].id_str:
next_tweets.pop(0)
tweets += next_tweets
for tweet in tweets:
rt_sources = get_rt_sources(tweet.text)
if not rt_sources:
continue
for rt_source in rt_sources:
if rt_source[0] == '@':
rt_source = rt_source[1:]
g.add_edge(rt_source, tweet.user.screen_name)
write_dot(g, "keyword.dot")
def visualize_mdp(mdp, filename):
log.info('in the visualize_mdp function')
import pydot
import networkx as nx
from networkx.drawing.nx_agraph import write_dot
G = nx.DiGraph()
for s in mdp['states']:
for a in s['actions']:
for t in a['transitions']:
ecolor = 'red' if a['id'] else 'green'
elabel = 'p={}, r={}'.format(t['probability'], t['reward'])
G.add_edge(s['id'], t['to'], color=ecolor, label=elabel)
log.info('writing dot file')
write_dot(G, filename.replace('.json', '.dot'))
g = pydot.graph_from_dot_file(filename.replace('.json', '.dot'))[0]
log.info('writing png from dot file')
g.write_png(filename.replace('.json', '.png'))
log.info('removing intermediate dot file')
os.remove(filename.replace('.json', '.dot'))
return filename.replace('.json', '.png')
def to_dot(self, dest_path):
if not dest_path.endswith('.dot'):
dest_path += '.dot'
write_dot(self.g, dest_path)
return dest_path
def plot_graph_and_sol(graph_copy, solution):
G = nx.Graph()
for edge in graph_copy._edges:
G.add_edge(edge._u,
edge._v,
label='{}={}'.format(edge._weights, edge.get_weight()))
edge_path_shortest = []
edge_path_second = []
if len(solution._paths) >= 1:
path = solution._paths[1]._path
edge_path_shortest = [(u, v) for (u, v, d) in G.edges(data=True)
if any([u, v] == path[i:i + 2]
for i in range(len(path) - 1)) or any(
[v, u] == path[i:i + 2]
for i in range(len(path) - 1))]
for (u, v) in edge_path_shortest:
G[u][v]['color'] = 'red'
G[v][u]['color'] = 'red'
if len(solution._paths) >= 2:
path = solution._paths[2]._path
edge_path_second = [(u, v) for (u, v, d) in G.edges(data=True)
if any([u, v] == path[i:i + 2]
for i in range(len(path) - 1)) or any(
[v, u] == path[i:i + 2]
for i in range(len(path) - 1))]
for (u, v) in edge_path_second:
if G[u][v].get('color') == 'red' or G[v][u].get('color') == 'red':
G[u][v]['color'] = '0.5:blue;0.5:red'
G[v][u]['color'] = '0.5:blue;0.5:red'
else:
G[u][v]['color'] = 'blue'
G[v][u]['color'] = 'blue'
write_dot(G, 'my_g.dot')
def __init__(self):
self.parser = None
self.args = None
self.project = None
self.cfg = None
self._create_parser()
self.args = self.parser.parse_args()
self.ext = 'svg'
self.fname = ''
if self.args.outfile:
self.fname, self.ext = os.path.splitext(self.args.outfile)
if self.ext != '.svg' and self.ext != '.dot':
l.error(
'Wrong output file foramt! Only support for .svg and .dot')
raise Exception('Invalid Input')
self._create_cfg()
if self.ext == '.dot':
write_dot(self.cfg.graph, self.args.outfile)
l.info("CFG is exported to " + self.args.outfile)
else:
self._postprocess_cfg()
if self.fname:
endpoint = CFGVisEndpoint('cfg', self.cfg)
for addr in self.addrs:
endpoint.serve(addr, fname=self.fname)
else:
self._launch()
self.app = CFGExplorer(start_url='/api/cfg/%#08x' %
self.addrs[0],
port=self.args.port)
self.add_endpoints()
def debug_graph(gr, name="G"):
"""Some documentation"""
write_dot(gr, '%s.dot' % name)
lines = open('%s.dot' % name).read().split("\n")
new_lines = []
last_node = None
for l in lines:
if len(l.strip()) == 0:
continue
if l.strip()[0] == '"' and l.find("->") < 0:
last_node = []
last_node.append(l)
elif (last_node is not None) and (l.find("];") < 0):
last_node.append(l)
elif (last_node is not None) and (l.find("];") > 0):
last_node.append(l)
subject = [l1.split("subject=")[1].split("]")[0] for l1 in last_node if l1.find("subject=") >= 0][0]
new_lines.append("subgraph cluster_%s {" % subject)
for l1 in last_node:
new_lines.append(l1)
new_lines.append("}")
last_node = None
else:
new_lines.append(l)
open('%s.cluster.dot' % name, "w").write("\n".join(new_lines))
#os.system('dot -Tpdf %s.dot -o %s.pdf' % (name, name))
os.system('dot -Tpng %s.cluster.dot -o %s.png' % (name, name))
return ("%s.png" % name)
def visualize_mdp(mdp, filename):
log.info('in the visualize_mdp function')
import pydot
import networkx as nx
from networkx.drawing.nx_agraph import write_dot
G=nx.DiGraph()
for s in mdp['states']:
for a in s['actions']:
for t in a['transitions']:
ecolor='red' if a['id'] else 'green'
elabel='p={}, r={}'.format(t['probability'], t['reward'])
G.add_edge(s['id'], t['to'],
color=ecolor,
label=elabel)
log.info('writing dot file')
write_dot(G, filename.replace('.json', '.dot'))
g = pydot.graph_from_dot_file(filename.replace('.json', '.dot'))[0]
log.info('writing png from dot file')
g.write_png(filename.replace('.json', '.png'))
log.info('removing intermediate dot file')
os.remove(filename.replace('.json', '.dot'))
return filename.replace('.json', '.png')
def DAGGen(path, N, p, id):
"""
Erdos-Renyi Random digraph (sort of)
with number of Nodes = N and edge
connection probability = p
"""
G = nx.DiGraph()
for u in range(N):
b = random.choice(ut.BENCH)
G.add_node(u,
bench=b,
aet=ut.AETDICT[b],
bet=ut.BETDICT[b],
ap=ut.APDICT[b],
bp=ut.BPDICT[b],
stack=1,
alloc=0)
rv = bernoulli(p)
for u in range(N):
for v in range(u + 1, N):
if rv.rvs() == 1:
G.add_edge(u, v)
if nx.is_directed_acyclic_graph(G):
print(f'The Digraph{N}_{id} is acyclic')
nxdr.write_dot(G, f'{path}/random{N}_{id}.dot')
def draw_graph(self):
if self.debug >= 2:
print(nx.info(self.G))
if self.pos == "spring":
pos = nx.spring_layout(self.G)
elif self.pos == "circular":
pos = nx.circular_layout(self.G)
elif self.pos == "kamada":
pos = nx.kamada_kawai_layout(self.G)
elif self.pos == "random":
pos = nx.random_layout(self.G)
elif self.pos == "shell":
pos = nx.shell_layout(self.G)
elif self.pos == "spectral":
pos = nx.spectral_layout(self.G)
else:
pos = nx.spring_layout(self.G)
# plt.subplots_adjust(left=0.0, bottom=0.0, right=1.0,
# top=1.0, wspace=0.0, hspace=0.0)
if self.debug >= 1:
print("Drawing graph nodes...")
draw_graph_nodes(self.G, self.paths, pos, col_path, self.draw_grey)
if self.debug >= 1:
print("Drawing graph edges...")
draw_graph_edges(self.G, self.paths, pos, col_path, self.draw_grey)
# nx.draw_networkx_labels(self.G, pos)
# plt.axis('off')
if self.debug >= 1:
print("Displaying graph")
write_dot(self.G, self.pos + "_lemin.dot")
# plt.show()
write_dot(self.G, 'file.dot')
def export_graph_as_dot(self,
dependency_graph_between_bbl,
levels=None,
suffix='',
save_as_pdf=False):
if levels is None:
levels = {}
if dependency_graph_between_bbl.order():
self.log_handler.info(
"Starting dumping BB graph dependencies as PDF...")
from networkx.drawing.nx_agraph import write_dot
import networkx as nx
if len(levels) > 0:
for i in levels.keys():
val = levels[i]
for nd in val:
if i % 2:
dependency_graph_between_bbl.node[nd][
'color'] = 'red'
else:
dependency_graph_between_bbl.node[nd][
'color'] = 'blue'
base_file_name = self.prefix + 'depthGraph_bb' + suffix + self.appName
write_dot(dependency_graph_between_bbl, base_file_name + '.dot')
if save_as_pdf:
import pydot
(graph, ) = pydot.graph_from_dot_file(base_file_name + '.dot')
graph.write_pdf(base_file_name + '.pdf')
else:
self.log_handler.error("Cannot export graph as a PDF.")
def _plot_trackers(
sender_ids, # type: List[Union[Text, List[Event]]]
output_file, # type: Optional[Text]
endpoint, # type: EndpointConfig
unconfirmed=None # type: Optional[List[Event]]
):
"""Create a plot of the trackers of the passed sender ids.
This assumes that the last sender id is the conversation we are currently
working on. If there are events that are not part of this active tracker
yet, they can be passed as part of `unconfirmed`. They will be appended
to the currently active conversation."""
if not output_file or not sender_ids:
# if there is no output file provided, we are going to skip plotting
# same happens if there are no sender ids
return None
event_sequences = _fetch_events(sender_ids, endpoint)
if unconfirmed:
event_sequences[-1].extend(unconfirmed)
graph = visualize_neighborhood(event_sequences[-1],
event_sequences,
output_file=None,
max_history=2)
from networkx.drawing.nx_agraph import write_dot
write_dot(graph, output_file)
def draw_a_grn(self,
grn,
is_to_save=True,
save_path="",
file_name="",
with_labels=False):
# drawing
# pos = nx.spring_layout(grn)
if isinstance(grn, list):
grn = self.generate_directed_grn(grn)
pos = nx.circular_layout(grn)
node_no = len(grn.nodes())
partition = {}
for i in range(node_no):
partition[i] = int(i / 5)
# pos = draw_communities.community_layout(grn, partition)
nx.draw(grn,
pos,
node_color=partition.values(),
with_labels=with_labels,
edge_color=nx.get_edge_attributes(grn, 'color').values())
if not is_to_save:
plt.show()
if is_to_save:
if save_path == "" or file_name == "":
raise Exception('Save path is not specified.')
plt.savefig(save_path + os.sep + file_name)
plt.close()
for key, value in np.ndenumerate(grn):
grn.node[key[0]]['pos'] = value
write_dot(grn, save_path + os.sep + 'directed_graph.dot')
def draw_graph(self):
G = nx.DiGraph()
stack = [(self.root, 1, 0, '')]
ni = 2
labels = {}
edge_labels = {}
while len(stack) > 0:
node, curr, parent, weight = stack.pop()
G.add_node(curr)
labels[curr] = node.attr_id if len(self.labels) == 0 or len(node.value) == 0 \
else self.labels[node.attr_id]
if parent != 0:
G.add_edge(parent, curr)
edge_labels[(parent, curr)] = weight
for v in node.value:
stack.append((node.value[v], ni, curr, v))
ni += 1
write_dot(G, 'test.dot')
plt.title('Decision Tree')
pos = graphviz_layout(G, prog='dot')
nx.draw(G,
pos,
node_color='pink',
arrows=True,
labels=labels,
node_size=2000)
nx.draw_networkx_edge_labels(G,
pos,
edge_labels=edge_labels,
font_color='red')
plt.show()
def tranform_swaps_to_cnots(self):
ghw = self.G_hw
swapIDs = []
for gate_id in ghw.nodes:
dt = ghw.nodes[gate_id]['details']
if not dt['type'] == "SWAP":
continue
swapIDs.append(gate_id)
for gate_id in swapIDs:
dt = ghw.nodes[gate_id]['details']
q1 = dt['hwqubits'][0]
q2 = dt['hwqubits'][1]
if q2 in self.mDigraph[q1]:
#q1->q2 exists
#swap sequence (q1->q2), (q2->q1), (q1->q2)
newQ1 = q1
newQ2 = q2
elif q1 in self.mDigraph[q2]:
#q2->q1 exists
#swap sequence (q2->q1), (q1->q2), (q2->q1)
newQ1 = q2
newQ2 = q1
parentsL = [p for p in ghw.predecessors(gate_id)]
childrenL = [c for c in ghw.successors(gate_id)]
ctime0 = dt['startTime']
connect1, ctime1 = self._add_direction_aware_cnot(
ghw, newQ1, newQ2, parentsL, ctime0)
connect2, ctime2 = self._add_direction_aware_cnot(
ghw, newQ2, newQ1, connect1, ctime1)
connect3, ctime3 = self._add_direction_aware_cnot(
ghw, newQ1, newQ2, connect2, ctime2)
self._connect_nodes_all_pairs(ghw, connect3, childrenL)
ghw.remove_node(gate_id)
assert (ctime3 - ctime0 == dt['duration'])
write_dot(self.G_hw, "G_final.dot")
def extract_forward_slice_chunk_bb(self, forward_slice_graph,
slice_root_node, function_name,
window_size):
basic_block_data_flow_graph = nx.DiGraph()
bb_nodes = defaultdict(list)
# root_basic_block = forward_slice_graph.nodes[slice_root_node]['basic_block_id']
# start_time = default_timer()
# seen_nodes = []
# print 'start building bb graph ...'
for node in forward_slice_graph.nodes:
#seen_nodes.append(node)
if 'basic_block_id' in forward_slice_graph.nodes[node]:
node_basic_block_id = forward_slice_graph.nodes[node][
'basic_block_id']
bb_nodes[str(node_basic_block_id)].append(node)
basic_block_data_flow_graph.add_node(node_basic_block_id)
for succ_node in forward_slice_graph.successors(node):
#if su
if 'basic_block_id' in forward_slice_graph.nodes[node]:
succ_node_basic_block_id = forward_slice_graph.nodes[
succ_node]['basic_block_id']
if node_basic_block_id != succ_node_basic_block_id:
basic_block_data_flow_graph.add_edge(
node_basic_block_id, succ_node_basic_block_id)
# elapsed_time = default_timer() - start_time
# print 'BB graph finding', elapsed_time
# print 'End building bb graph!'
bbgraph_name = '{}_{}.bbgraph.dot'.format(
self.pdg_graph_file, self.slice_root_nodes[slice_root_node])
bbgraph_name = self.add_dependency_prefix(bbgraph_name)
write_dot(basic_block_data_flow_graph, bbgraph_name)
self.get_all_subgraphs_size(basic_block_data_flow_graph,
forward_slice_graph, window_size,
slice_root_node, function_name, bb_nodes)
def draw_entity_disambiguation_graph(self):
print 'Drawing Entity Disambiguation Graph......',
graph_name = self.graph_path + 'edg' + str(self.table_number)
write_dot(self.miniEDG, graph_name + '.dot')
os.system('dot -Tsvg ' + graph_name + '.dot' + ' -o ' + graph_name +
'.svg')
print 'Done!'
def export_graph(graph_to_export, name_of_file_without_extension):
# Possibilities: adjlist, dot, edgelist, gexf, gml, graphml, multiline_adjlist, pajek, yaml
write_dot(graph_to_export, name_of_file_without_extension + ".dot")
logger.info("File saved: %s", name_of_file_without_extension + ".dot")
return
def draw_graph(G,edgeLabels):
# G = nx.DiGraph()
# figure(num=None, figsize=(4, 4), dpi=80, facecolor='w', edgecolor='k')
# write dot file to use with graphviz
# run "dot -Tpng test.dot >test.png"
write_dot(G,'test.dot')
# same layout using matplotlib with no labels
plt.title('draw_networkx')
pos =graphviz_layout(G, prog='dot')
# nx.draw(G, pos, with_labels=True, arrows=True, font_size=8)
nx.draw(G, pos, with_labels=True, arrows=True, font_size=8, node_size=8)
nx.draw_networkx_edge_labels(G,pos,edge_labels=edgeLabels,font_color='red',font_size=8)
# for v in G.node():
# print(len(v))
# nx.draw(G, with_labels=True, arrows=True)
# nx.draw_networkx_nodes(G, pos, node_size=[len(v) * 100 for v in G.nodes()])
plt.show()
def visualizegraphalgorithm(algorithm, name, nodes, edges, scale):
G = nx.Graph()
G.add_nodes_from(nodes)
try:
G.add_weighted_edges_from(edges, color = 'black')
except:
G.add_edges_from(edges, color = 'black')
algorithms = {"prim":graphListFromPrim, "kruskal":graphListFromKruskal, "depthsearch":graphListFromDepthSearch}
graphlist = algorithms[algorithm](G)
for graph in graphlist:
setlabelweight(graph)
importantlines.append(r"%END" + "\n")
importantlines.append(r"\begin{frame}" + "\n")
if not os.path.exists(name):
os.mkdir(name)
parentpath = os.getcwd()
os.chdir(name)
for index, graph in enumerate(graphlist):
filename = 'graph' + str(index) + '.dot'
filenametikz = 'graph' + str(index) + '.tex'
write_dot(graph, filename)
os.system(f"dot -Txdot {filename} | dot2tex -ftikz -tmath --figonly --tikzedgelabels --prog=circo --graphstyle='scale={scale}, auto' > {filenametikz}")#--nodeoptions scale=0.5
importantlines.append(f"\\only<{index+1}>" + "{\n")
importantlines.append(r"\input{" + name + "/" + filenametikz + "}\n")
importantlines.append("}\n")
importantlines.append(r"\end{frame}")
os.chdir(parentpath)
with open(plotframe, "w") as f:
f.writelines(importantlines)
def draw(self, method="graphviz", title="knowledge_graph", save_path=""):
"""
This function helps to visualize a network DiGraph
:param method: which visualization method to use
:param title: name of the graph
:param save_path: save directory
:return:
"""
if method == "graphviz":
# There are two ways to visualize networkx graph
# 1. write dot file to use with graphviz
# run "dot -Tpng test.dot > test.png"
dot_path = os.path.join(save_path, '{}.dot'.format(title))
png_path = os.path.join(save_path, '{}.png'.format(title))
write_dot(self.graph, dot_path)
cmd = 'dot -Tpng {} > {}'.format(dot_path, png_path)
os.system(cmd)
elif method == "matplotlib":
# 2. same layout using matplotlib with no labels
# Not so good
plt.title(title)
pos = graphviz_layout(self.graph, prog='dot')
nx.draw(self.graph, pos, with_labels=False, arrows=True)
plt.savefig(os.path.join(save_path, 'nx_test.png'))
def plot_image_hierarchy(fig: plt.Figure, G: nx.Graph):
# Adapted from https://stackoverflow.com/questions/53967392/creating-a-graph-with-images-as-nodes
ax = fig.gca()
ax.set_aspect('equal', adjustable='box')
write_dot(G, 'test.dot')
pos = graphviz_layout(G, prog='dot', args='-Nsep="+1000,+1000";')
nx.draw_networkx_edges(G, pos, ax=ax)
trans = ax.transData.transform
trans2 = fig.transFigure.inverted().transform
piesize = 0.2 # this is the image size
p2 = piesize / 2.0
for n in G:
xx, yy = trans(pos[n]) # figure coordinates
xa, ya = trans2((xx, yy)) # axes coordinates
a = plt.axes([xa - p2, ya - p2, piesize, piesize])
a.set_aspect('equal')
a.imshow(plt.imread(G.node[n]['image']))
a.set_xticks([])
a.set_yticks([])
# a.set_title(n.name)
ax.axis('off')
def breadthFirstSearch(self, root):
from collections import deque
import networkx as nx
from networkx.drawing.nx_agraph import write_dot, graphviz_layout
import matplotlib.pyplot as plt
G = nx.DiGraph()
G.add_node(root)
visited_nodes = list()
visited_nodes.append(root)
queue = deque([root])
tree = dict()
while len(queue) > 0:
node = queue.popleft()
adj_nodes = self.nodes[node].adj_nodes.keys()
remaining_elements = set(adj_nodes).difference(set(visited_nodes))
tree[node] = list(remaining_elements)
if len(remaining_elements) > 0:
for elem in sorted(remaining_elements):
G.add_node(elem)
G.add_edge(node, elem)
visited_nodes.append(elem)
queue.append(elem)
write_dot(G, 'bfs_tree.dot')
plt.title('BFS TREE')
pos = graphviz_layout(G, prog='dot')
nx.draw(G, pos, with_labels=False, arrows=True)
plt.savefig('bfs_tree.png')
def draw(self,
dot_file_name='default.dot',
image_file_name='default.png',
font_size=5,
node_size=200,
line_width=0.25,
label_size=5):
write_dot(self.G, dot_file_name)
plt.figure()
plt.title(self.title)
# layout setting, hierarchical
pos = graphviz_layout(self.G, prog='dot')
nx.draw(self.G,
pos,
with_labels=True,
arrows=False,
node_size=node_size,
font_size=font_size,
width=line_width)
nx.draw_networkx_edge_labels(self.G,
pos,
edge_labels=self.edge_labels,
font_size=label_size)
# output
plt.show()
plt.savefig(image_file_name, dpi=1000)
def save_graphviz(g, fname):
dag = g.copy()
counter = defaultdict(int)
for n in dag.nodes(True):
n[1]["shape"] = "box"
if dag.in_degree(n[0]) == 0:
counter["raw"] += 1
n[1]["color"] = "blue"
if dag.out_degree(n[0]) == 0:
n[1]["color"] = "deeppink"
if dag.in_degree(n[0]) > 0:
counter["output"] += 1
if dag.out_degree(n[0]) > 0 and dag.in_degree(n[0]) > 0:
counter["intermediate"] += 1
pprint.pprint(counter)
for n in dag.nodes(True):
if not dag.has_node(n[0]):
continue
contract_inputs(dag, n)
write_dot(dag, fname)
def _plot_multi_graph(G):
"""Given a multigraph G, produces a corresponding visualization
Returns void
"""
write_dot(G, 'blockchain/multi_blockchain.dot')
subprocess.call("./convert.sh", shell=True)
def domain_graphs_with_subgraphs(nodes, edges, subgraphs, graphs_dir, language):
domain_graph = nx.MultiDiGraph()
domain_graph.add_nodes_from(nodes)
for edge in edges:
domain_graph.add_edge(edge[0], edge[1], weight=float(edges[edge]), label=str(edges[edge]))
for lang, nodelist in subgraphs:
domain_graph.subgraph(nodelist, name=lang)
# subgr.name = lang
# saving file to draw it with dot-graphviz
# changing overall graph view, default is top-bottom
domain_graph.graph['graph'] = {'rankdir': 'LR'}
write_dot(domain_graph, os.path.join(graphs_dir, 'domains_' + language + '_links.dot'))
def write_dot_output(graphml_file, outfile=''):
"""
This function takes the graphml file and writes the dot file for visualization
:param graphml_file: Input file in graphml format
:param outfile: Output file name
:return: path of output file
"""
graph = nx.read_graphml(graphml_file) # read the graphml file to a graph
# use the infile name and path if no outfile is specified
if outfile == '':
outfile = change_extension('.dot', graphml_file)
write_dot(graph, outfile)
print('dot file written to {0}'.format(outfile))
def plot(g, step=""):
import os
for n,d in g.nodes(data=True):
d["label"]="{} {} {} ({})".format(n, d['_name'], d['_self_coverage'], d['_coverage'])
if not d['_valid'] or not d['_tested']: d["style"]="dotted"
else: d["style"]="solid"
if d['_tested']:
d["style"]="solid"
if not d['_matching']: d['color']="red"
else: d['color']="green"
if d['_to_test']: d['color']="orange"
for u,v,d in g.edges(data=True):
d["label"] = round(d["weight"], 2)
write_dot(g,"{0}/graph_{1}.dot".format(var.CERE_PROFILE_PATH, step))
try:
logger.debug(subprocess.check_output("dot -Tpdf {0}/graph_{1}.dot -o {0}/graph_{1}.pdf".format(var.CERE_PROFILE_PATH, step), stderr=subprocess.STDOUT, shell=True))
except subprocess.CalledProcessError as err:
logger.error(str(err))
logger.error(err.output)
logger.error("Cannot create the pdf")
def plot_gv(bn, save=False):
def execute(command):
command = ' '.join(command)
process = subprocess.Popen(command,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output = process.communicate()[0]
returncode = process.returncode
if returncode == 0:
return True, output
else:
return False, output
cmd = ['mkdir' , 'neuroBN/plotting/images']
p = execute(cmd)
G = nx.DiGraph(bn.E)
write_dot(G,"neuroBN/plotting/images/bn.dot")
cmd = ['/usr/local/bin/dot', '-Tpng' ,
'neuroBN/plotting/images/bn.dot',
'>neuroBN/plotting/images/bn.png']
p = execute(cmd)
plt.figure(facecolor="white")
img=mpimg.imread('neuroBN/plotting/images/bn.png')
_img = plt.imshow(img, aspect='auto')
plt.axis('off')
plt.show(_img)
if not save:
cmd = ['rm' , '-r', 'neuroBN/plotting/images']
p = execute(cmd)
else:
cmd = ['rm', '-r', 'neuroBN/plotting/images/bn.dot']
p = execute(cmd)
def plotGraph(self):
self.G = nx.DiGraph()
for i in range(0,self.mutalInformationMatrix.shape[0]+1):
self.G.add_node(i)
self.G.add_edges_from(self.graphMst)
#ADD THE EDGE FOR THE LABEL NODE TOO
for i in range(0,self.mutalInformationMatrix.shape[0]):
self.G.add_edge(self.X_train.shape[1]-1,i)
self.renameNodes()
pos=nx.spring_layout(self.G)
nx.draw_networkx_nodes(self.G,pos)
nx.draw_networkx_labels(self.G,pos)
nx.draw_networkx_edges(self.G,pos)
plt.show()
#A=A=nx.to_agraph(G)
pos = graphviz_layout(self.G)
#nx.draw(G,pos)
#plt.show()
write_dot(self.G,'BayesNet4.dot')
print 'so far so good'
def iplot(bn, h=350, w=450):
"""
Inline Plotting of a BayesNet object
"""
def execute(command):
command = ' '.join(command)
process = subprocess.Popen(command,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output = process.communicate()[0]
returncode = process.returncode
if returncode == 0:
return True, output
else:
return False, output
cmd = ['mkdir' , 'neuroBN/plotting/images']
p = execute(cmd)
G = nx.DiGraph(bn.E)
write_dot(G,"neuroBN/plotting/images/bn.dot")
cmd = ['/usr/local/bin/dot', '-Tpng' ,
'neuroBN/plotting/images/bn.dot',
'>neuroBN/plotting/images/bn.png']
p = execute(cmd)
im = Image.open("neuroBN/plotting/images/bn.png")
out = im.resize((w,h))
cmd = ['rm' , '-r', 'neuroBN/plotting/images']
p = execute(cmd)
return out
def draw_graph_to_file(self, filename="graph",
diff=None,
hide_unconnected_nodes=False,
hide_image_edges=True,
edge_colors=False,
node_labels=False,
weight_labels=False,
image_labels=False,
color_scheme="VESTA",
keep_dot=False,
algo="fdp"):
"""
Draws graph using GraphViz.
The networkx graph object itself can also be drawn
with networkx's in-built graph drawing methods, but
note that this might give misleading results for
multigraphs (edges are super-imposed on each other).
If visualization is difficult to interpret,
`hide_image_edges` can help, especially in larger
graphs.
:param filename: filename to output, will detect filetype
from extension (any graphviz filetype supported, such as
pdf or png)
:param diff (StructureGraph): an additional graph to
compare with, will color edges red that do not exist in diff
and edges green that are in diff graph but not in the
reference graph
:param hide_unconnected_nodes: if True, hide unconnected
nodes
:param hide_image_edges: if True, do not draw edges that
go through periodic boundaries
:param edge_colors (bool): if True, use node colors to
color edges
:param node_labels (bool): if True, label nodes with
species and site index
:param weight_labels (bool): if True, label edges with
weights
:param image_labels (bool): if True, label edges with
their periodic images (usually only used for debugging,
edges to periodic images always appear as dashed lines)
:param color_scheme (str): "VESTA" or "JMOL"
:param keep_dot (bool): keep GraphViz .dot file for later
visualization
:param algo: any graphviz algo, "neato" (for simple graphs)
or "fdp" (for more crowded graphs) usually give good outputs
:return:
"""
if not which(algo):
raise RuntimeError("StructureGraph graph drawing requires "
"GraphViz binaries to be in the path.")
# Developer note: NetworkX also has methods for drawing
# graphs using matplotlib, these also work here. However,
# a dedicated tool like GraphViz allows for much easier
# control over graph appearance and also correctly displays
# mutli-graphs (matplotlib can superimpose multiple edges).
g = self.graph.copy()
g.graph = {'nodesep': 10.0, 'dpi': 300, 'overlap': "false"}
# add display options for nodes
for n in g.nodes():
# get label by species name
label = "{}({})".format(str(self.structure[n].specie), n) if node_labels else ""
# use standard color scheme for nodes
c = EL_COLORS[color_scheme].get(str(self.structure[n].specie.symbol), [0, 0, 0])
# get contrasting font color
# magic numbers account for perceived luminescence
# https://stackoverflow.com/questions/1855884/determine-font-color-based-on-background-color
fontcolor = '#000000' if 1 - (c[0] * 0.299 + c[1] * 0.587
+ c[2] * 0.114) / 255 < 0.5 else '#ffffff'
# convert color to hex string
color = "#{:02x}{:02x}{:02x}".format(c[0], c[1], c[2])
g.add_node(n, fillcolor=color, fontcolor=fontcolor, label=label,
fontname="Helvetica-bold", style="filled", shape="circle")
edges_to_delete = []
# add display options for edges
for u, v, k, d in g.edges(keys=True, data=True):
# retrieve from/to images, set as origin if not defined
to_image = d['to_jimage']
# set edge style
d['style'] = "solid"
if to_image != (0, 0, 0):
d['style'] = "dashed"
if hide_image_edges:
edges_to_delete.append((u, v, k))
# don't show edge directions
d['arrowhead'] = "none"
# only add labels for images that are not the origin
if image_labels:
d['headlabel'] = "" if to_image == (0, 0, 0) else "to {}".format((to_image))
d['arrowhead'] = "normal" if d['headlabel'] else "none"
# optionally color edges using node colors
color_u = g.node[u]['fillcolor']
color_v = g.node[v]['fillcolor']
d['color_uv'] = "{};0.5:{};0.5".format(color_u, color_v) if edge_colors else "#000000"
# optionally add weights to graph
if weight_labels:
units = g.graph.get('edge_weight_units', "")
if d.get('weight'):
d['label'] = "{:.2f} {}".format(d['weight'], units)
# update edge with our new style attributes
g.edges[u, v, k].update(d)
# optionally remove periodic image edges,
# these can be confusing due to periodic boundaries
if hide_image_edges:
for edge_to_delete in edges_to_delete:
g.remove_edge(*edge_to_delete)
# optionally hide unconnected nodes,
# these can appear when removing periodic edges
if hide_unconnected_nodes:
g = g.subgraph([n for n in g.degree() if g.degree()[n] != 0])
# optionally highlight differences with another graph
if diff:
diff = self.diff(diff, strict=True)
green_edges = []
red_edges = []
for u, v, k, d in g.edges(keys=True, data=True):
if (u, v, d['to_jimage']) in diff['self']:
# edge has been deleted
red_edges.append((u, v, k))
elif (u, v, d['to_jimage']) in diff['other']:
# edge has been added
green_edges.append((u, v, k))
for u, v, k in green_edges:
g.edges[u, v, k].update({'color_uv': '#00ff00'})
for u, v, k in red_edges:
g.edges[u, v, k].update({'color_uv': '#ff0000'})
basename, extension = os.path.splitext(filename)
extension = extension[1:]
write_dot(g, basename+".dot")
with open(filename, "w") as f:
args = [algo, "-T", extension, basename+".dot"]
rs = subprocess.Popen(args,
stdout=f,
stdin=subprocess.PIPE, close_fds=True)
rs.communicate()
if rs.returncode != 0:
raise RuntimeError("{} exited with return code {}.".format(algo, rs.returncode))
if not keep_dot:
os.remove(basename+".dot")
def display_networkx_graph(g):
dot_file = _to_tmp_file('.dot')
write_dot(g, dot_file)
display_dot(dot_file)
#!/usr/bin/python
import networkx as nx
from networkx.drawing.nx_agraph import read_dot
from networkx.drawing.nx_agraph import write_dot
from networkx.readwrite import json_graph
#G = read_dot("all_nobreak.dot")
g = read_dot("inkscape-mergecycl.dot")
cycles = list(nx.simple_cycles(g))
print cycles
for n1 in g.nodes_iter():
if g.has_edge(n1, n1):
g.remove_edge(n1, n1)
for n2 in g.successors(n1):
for n3 in g.successors(n2):
for n4 in nx.dfs_preorder_nodes(g, n3):
if g.has_edge(n1, n4):
g.remove_edge(n1, n4)
#nx.write_graphml(g, "inkscape-reduced.graphml")
write_dot(g,"inkscape-reduced.dot")
nx.write_gml(g,"inkscape-reduced.gml")
g = nx.convert_node_labels_to_integers(g)
data = json_graph.node_link_data(g)
print data
#import json
#serial = json.dumps(data)
#print serial
# Aric Hagberg <*****@*****.**>
# Dan Schult <*****@*****.**>
# Pieter Swart <*****@*****.**>
# All rights reserved.
# BSD license.
import networkx as nx
# and the following code block is not needed
# but we want to see which module is used and
# if and why it fails
try:
import pygraphviz
from networkx.drawing.nx_agraph import write_dot
print("using package pygraphviz")
except ImportError:
try:
import pydot
from networkx.drawing.nx_pydot import write_dot
print("using package pydot")
except ImportError:
print()
print("Both pygraphviz and pydot were not found ")
print("see https://networkx.github.io/documentation/latest/reference/drawing.html")
print()
raise
G = nx.grid_2d_graph(5, 5) # 5x5 grid
write_dot(G, "grid.dot")
print("Now run: neato -Tps grid.dot >grid.ps")
def makeNetworkDot(networkGraph):
# Constants definition
# List of load types with a generation icon.
GENERATION_TYPES=['G']
# List of load types with an industrial icon.
INDUSTRIAL_TYPES=['I1','I2','I3']
# Map where keys are bus ids and value graphviz ids.
idToGvId={}
# Style of the graph
g=networkx.Graph()
# Create nodes
unknownCount=len(networkGraph.nodes())
transformersCount=0
for n,ndata in networkGraph.nodes(data=True):
# Take care of unknown nodes
id=None
internalId=id
try:
internalId=ndata["id"]
id="BUS%s"%ndata["internalId"]
except KeyError:
unknownCount-=1
internalId="?"
id="BUS%s"%(-unknownCount)
idToGvId[n]=id
# Add styled node
g.add_node(id,{"xlabel":internalId,"shape":"box","style":"filled","color":"#000000","fixedsize":"true","width":0.5,"height":0.075,"label":" ","fontsize":10,"id":id})
# Transformer
tId=None
try:
if SHOW_TRANSFORMERS and len(ndata["transformers"]) >= 1:
t=ndata["transformers"][0]
transformersCount+=1
tId="TF%s"%t.internalId
g.add_node(tId,{"xlabel":t.id,"shape":"circle","style":"filled","color":"#000000","fixedsize":"true","width":0.15,"height":0.15,"label":" ","fontsize":10})
g.add_edge(id,tId,{"weight":10000})
except KeyError:
pass
# Load
load=ndata["load"]
if load is not None:
loadId="LOAD%s"%load.internalId
edgeAttr={"weight":10000}
if load.loadType in GENERATION_TYPES:
g.add_node(loadId,{"label": "~","shape":"circle","style":"bold","color":"#000000","fixedsize":"true", "penwidth":2, "width":0.2, "height":0.2,"fontsize":18})
elif load.loadType in INDUSTRIAL_TYPES:
g.add_node(loadId,{"xlabel":load.loadType,"label":" ","shape":"invtriangle","color":"#000000","fixedsize":"true", "penwidth":2, "width":0.2, "height":0.2,"portPos":"n","fontsize":10})
edgeAttr["tailport"]="n"
else:
g.add_node(loadId,{"xlabel":load.loadType,"label":" ","style":"filled","shape":"invtriangle","color":"#000000","fixedsize":"true", "penwidth":2, "width":0.2, "height":0.2,"portPos":"n","fontsize":10})
edgeAttr["tailport"]="n"
# Connect the load
if tId is None:
g.add_edge(id,loadId,edgeAttr)
else:
g.add_edge(tId,loadId,edgeAttr)
# Create edges
for u,v,edata in networkGraph.edges(data=True):
if not edata["closed"]:
continue
uId=idToGvId[u]
vId=idToGvId[v]
if not g.has_edge(uId,vId):
w=10/(1+edata["length"])
g.add_edge(uId,vId,{"label":" . ","fontsize":10, "id": "LINE%s"%(edata["internalId"]+1)})
# Detect cycles
try:
cycles = networkx.cycle_basis(g)
for cy in cycles:
networkx.set_node_attributes(g,'color',dict(zip(cy,['#FF0000']*len(cy))))
print([g.node[b]['xlabel'] for b in cy])
print("Cycles: %d" %len(cycles))
except Exception as e:
print("Error %s" % e)
if not networkx.is_connected(g):
print("Warning: graph is not connected.")
components = [c for c in sorted(networkx.connected_components(g), key=len, reverse=True)]
print("Warning: graph contains %d connected components:" % len(components))
print(components)
write_dot(g,'network.gv')
# Convert to pdf and gml
with open(os.devnull, 'wb') as devnull:
subprocess.check_call(['neato', '-Tsvg', '-onetwork.svg', 'network.gv'], stdout=devnull, stderr=subprocess.STDOUT)
subprocess.check_call(['neato', '-Tpdf', '-onetwork.pdf', 'network.gv'], stdout=devnull, stderr=subprocess.STDOUT)
subprocess.check_call(['gv2gml', '-onetwork.gml', 'network.gv'], stdout=devnull, stderr=subprocess.STDOUT)
''' Extracts the attributes of the vertices and edges from
the gml data structure
<tt>return</tt> the graph with the standard dot attributes'''
graphics = nx.get_node_attributes(G, "graphics")
# print(graphics)
for k in graphics.keys():
pos = str(graphics[k]['x']) +"," + str(graphics[k]['y'])
nx.set_node_attributes(G, {k:pos}, 'pos')
nx.set_node_attributes(G, {k:""}, "graphics")
nx.set_node_attributes(G, {k:k}, "label")
G = nx.Graph(G)
return G
g_path = sys.argv[1]
outputpath = sys.argv[2]
g_name = os.path.basename(g_path).split(".")[0]
# Reading graph and subgraph
G = nx.read_gml(g_path)
G = nx.Graph(G)
G = set_graph_properties(G)
write_dot(G, outputpath)
