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 read_dot_file_with_arbitrary_node_id(file_name):
import networkx as nx
import pygraphviz as pgv
from networkx.drawing.nx_agraph import read_dot as nx_read_dot
G_labeled = nx_read_dot(file_name)
#print(G.edges())
G_labeled = nx.Graph(G_labeled)
#print(G.edges())
node_coords = []
label_to_id = dict()
id_to_label = dict()
id_count = 0
for v in G_labeled.nodes():
label_to_id[v] = id_count
id_to_label[id_count] = v
id_count += 1
G = nx.Graph()
for u, v in G_labeled.edges():
G.add_edge(label_to_id[u], label_to_id[v])
for i in range(G.number_of_nodes()):
coords = [float(c) for c in G_labeled.nodes[id_to_label[i]]['pos'].split(',')]
node_coords.append(coords)
edge_list = []
for e in G.edges():
u, v = e
edge_list.append([int(u), int(v)])
#print(edge_list)
return node_coords, edge_list, label_to_id, id_to_label
def dot_to_txt(input_file, output_file):
G = nx_read_dot(input_file)
print(nx.info(G))
f = open(output_file, 'w')
f.write(str(len(G.nodes())) + '\n')
id_to_name = dict()
name_to_id = dict()
count = 0
for node_id in G.nodes():
node = G.node[node_id]
name_to_id[node_id] = count
count += 1
x, y = vertexmanager.getCoordinate(node)
f.write(str(x) + ' ' + str(y) + '\n')
print(name_to_id)
for edg in G.edges():
f.write(str(name_to_id[edg[0]]) + " " + str(name_to_id[edg[1]]) + "\n")
f.close()
def read_dot_file(file_name):
import networkx as nx
import pygraphviz as pgv
from networkx.drawing.nx_agraph import read_dot as nx_read_dot
G = nx_read_dot(file_name)
#print(G.edges())
G = nx.DiGraph(G)
#print(G.edges())
node_coords = []
for i in range(G.number_of_nodes()):
coords = [float(c) for c in G.nodes[str(i)]['pos'].split(',')]
node_coords.append(coords)
edge_list = []
for e in G.edges():
u, v = e
edge_list.append([int(u), int(v)])
#print(edge_list)
return node_coords, edge_list
def convert_dot_to_txt(file_name):
G = nx_read_dot(file_name)
G = nx.Graph(G)
x = [0.0 for i in range(len(G.nodes()))]
y = [0.0 for i in range(len(G.nodes()))]
if has_position:
for n in G.nodes():
arr = G.node[n]['pos'].split(',')
x[int(n)]=float(arr[0])
y[int(n)]=float(arr[1])
edge_list = []
for e in G.edges():
u, v = e
edge_list.append([int(u), int(v)])
if file_name.startswith('dodec_and_twin'):
G = nx.Graph()
for e in edge_list:
u, v = e
G.add_edge(u-1, v-1)
if has_position:
write_as_txt(file_name[:len(file_name)-3]+'txt', edge_list, x, y)
else:
write_as_txt_random_position(file_name[:len(file_name)-3]+'txt', G)
graph_path = parameters[1]
tree_path = parameters[2]
outputpath = tree_path
if len(parameters) <= 3:
print("No properties to fetch given.")
print("Using default parameter: pos width height pos label weigth")
parameters = ["pos", "width", "height", "pos", "label", "weigth"]
# Fetching parameters list
properties_to_fetch = parameters[3:]
input_graph_name = os.path.basename(graph_path)
graph_name = input_graph_name.split(".")[1]
from_graph = nx_read_dot(graph_path)
from_graph = nx.Graph(from_graph)
to_graph = nx_read_dot(tree_path)
to_graph = nx.Graph(to_graph)
#
print(nx.info(from_graph))
print(nx.info(to_graph))
print(properties_to_fetch)
# looping over all properties to be fetched
for param in properties_to_fetch:
print("fetching: " + param)
nx.set_node_attributes(to_graph, nx.get_node_attributes(from_graph, param),
param)
bot_tree = nx_read_dot(folder_name + '/' + file_name[1])
top_tree = nx_read_dot(folder_name + '/' + file_name[0])
reduction_size_arr = [119]
file_names = ["Graph_500.dot"]
reduced_trees = reduce_tree(bot_tree, top_tree, reduction_size_arr)
for i in range(len(reduced_trees)):
fname = folder_name + '/' + file_names[i]
G = reduced_trees[i]
write_dot(G, fname)
'''
folder_name = "topics_iqbal"
file_name = ["Topics_Layer_1.dot", "Topics_Layer_2.dot"]
bot_tree = nx_read_dot(folder_name + '/' + file_name[0])
reduction_size_arr = [113, 100, 50]
file_names = ["Graph_200.dot", "Graph_100.dot", "Graph_50.dot"]
reduced_trees = reduce_tree(bot_tree, nx.Graph(), reduction_size_arr)
for i in range(len(reduced_trees)):
fname = folder_name + '/' + file_names[i]
G = reduced_trees[i]
write_dot(G, fname)
bot_tree = nx_read_dot(folder_name + '/' + file_name[1])
top_tree = nx_read_dot(folder_name + '/' + file_name[0])
reduction_size_arr = [400]
file_names = ["Graph_500.dot"]
reduced_trees = reduce_tree(bot_tree, top_tree, reduction_size_arr)
for i in range(len(reduced_trees)):
fname = folder_name + '/' + file_names[i]
distance = edge_length * i
x = origin_x + (distance) * math.cos(angle)
y = origin_y + (distance) * math.sin(angle)
lp_pos[v] = str(x) + "," + str(y)
placed_vertices.append(v)
i += 1
return lp_pos
tree_path = sys.argv[1]
# Main Graph
tree_path_name = os.path.basename(tree_path).split(".")[0]
# Reading graph and subgraph
G = nx_read_dot(tree_path)
placed_vertices = set()
leaves_paths = get_all_leaves_paths(G)
lens = sorted(leaves_paths.keys(), reverse=True)
# Place one longest path first
longest_index = lens[0]
angle = 0
origin_x = 0
origin_y = 0
longest_path = leaves_paths[longest_index].pop(0)
lp_pos = place_path(longest_path,
angle,
desired_edge_length,
# main
# Input
if len(sys.argv) < 4:
print('usage:python3 GD2Main.py graph_path output_folder_path metrics')
quit()
GRAPH_PATH = sys.argv[1]
OUTPUT_FOLDER = sys.argv[2] # Output folder
METRICS = sys.argv[3]
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)
# Metrics weights
compute_ue = 0 #Uniformity Edge lengths
compute_st = 1 # Stress
compute_sym = 0 # Symmetry
compute_np = 0 # Neighbor Preservation
compute_cr = 1 #Crossings
# Gradient Descente convergence threshold
def save_graph(G, outputpath):
G = nx.Graph(G)
write_dot(G, outputpath)
def extract_level(G, level):
G = nx.Graph(G)
levels_info = nx.get_node_attributes(G, 'level')
to_remove_nodes = [
n for n in levels_info.keys() if int(levels_info[n]) > level
]
G.remove_nodes_from(to_remove_nodes)
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_dot(g_path)
G = nx.Graph(G)
levels_info = nx.get_node_attributes(G, 'level')
levels = sorted(list(set(levels_info.values())))
for level in levels:
level = int(level)
sub_G = extract_level(G, level)
save_graph(sub_G, outputpath + g_name + "_" + str(level) + "_final.dot")
for e in edge_list:
u, v = e
if u>=len(D_x) or v>=len(D_x): continue
if u==j:
if not D_x[v]==D_x[j]: attraction_x += (1/param_a)*((D_x[v]-D_x[j])/abs(D_x[v]-D_x[j]))*abs(D_x[v]-D_x[j])**2
if not D_y[v]==D_y[j]: attraction_y += (1/param_a)*((D_y[v]-D_y[j])/abs(D_y[v]-D_y[j]))*abs(D_y[v]-D_y[j])**2
if v==j:
if not D_x[u]==D_x[j]: attraction_x += (1/param_a)*((D_x[u]-D_x[j])/abs(D_x[u]-D_x[j]))*abs(D_x[u]-D_x[j])**2
if not D_y[u]==D_y[j]: attraction_y += (1/param_a)*((D_y[u]-D_y[j])/abs(D_y[u]-D_y[j]))*abs(D_y[u]-D_y[j])**2
new_x, new_y = find_suitable_point_scale_up(j, repulsion_x+attraction_x, repulsion_y+attraction_y, D_x, D_y, edge_list, label_sizes, index_to_label)
D_x[j], D_y[j] = new_x, new_y
#draw_graph(D_x, D_y, edge_list[:len(D_x)-1], output_file, index_to_label, label_sizes)
if j == len(label_sizes)-1:
fnt_size = find_suitable_font_size_scale_up(j, D_x, D_y, edge_list, label_sizes, index_to_label)
label_sizes[len(label_sizes)-1] = fnt_size
max_diff = max(max_diff, math.sqrt((repulsion_x+attraction_x)**2+(repulsion_y+attraction_y)**2))
i = i+1
if i==15: break
#print("D_x, D_y:", D_x, D_y)
draw_graph(D_x, D_y, edge_list[:len(D_x)-1], output_file, index_to_label, label_sizes)
G = nx_read_dot('Layer1.dot')
#G2 = nx.Graph()
#G2.add_edges_from(G.edges())
#nx.draw(G2, cmap=plt.get_cmap('Set1'), with_labels=True)
#plt.show()
iterative_force_directed(G)
if os.path.exists(svgfullpath):
os.remove(svgfullpath)
# Convert the two csv files in svg for the score computation
scale = 1
svg = format_for_klapaukh.build_svg_networkx(G, scale)
format_for_klapaukh.write_svg(svgfullpath, svg)
# invoke the java pachage
p = Popen(['java', '-jar', 'kAnalyzer.jar', svgfullpath], stdout=PIPE)
output = p.stdout.read()
output_str = output.decode('utf-8')
score = get_reflectional_score_string(output_str)
print(output_str)
# Remove the created temp files if existf
if os.path.exists(svgfullpath):
os.remove(svgfullpath)
return score
#
G = nx_read_dot("/Users/felicedeluca/Desktop/nonsymmetric.dot")
# for i in range(0, 360):
# G = rotate(G, i)
score = get_symmetric_score(G)
# angle = rotate_to_ideal_symmetry(G)
print(score)
import math
import random
# Main Flow
t1path = sys.argv[1]
t2path = sys.argv[2]
outputpath = sys.argv[3]
# Main Graph
t1_name = os.path.basename(t1path).split(".")[0]
t2_name = os.path.basename(t2path).split(".")[0]
print(t1_name, t2_name)
# Reading graph and subgraph
G_t1 = nx_read_dot(t1path)
G_t2 = nx_read_dot(t2path)
# print(nx.info(G_t1))
# print(nx.info(G_t2))
t1_label_dict = nx.get_node_attributes(G_t1, 'label')
t2_label_dict = nx.get_node_attributes(G_t2, 'label')
for k in t1_label_dict.keys():
t1_label_dict[k] = t1_label_dict[k].encode('utf-8')
for k in t2_label_dict.keys():
t2_label_dict[k] = t2_label_dict[k].encode('utf-8')
nx.set_node_attributes(G_t1, t1_label_dict, 'label')
#Author #Felice De Luca #https://github.com/felicedeluca import sys import os import math import pygraphviz as pgv import networkx as nx from networkx.drawing.nx_agraph import write_dot from networkx.drawing.nx_agraph import read_dot as nx_read_dot import leavesoverlapremoval # Main Flow graph_path = sys.argv[1] outputpath = sys.argv[2] G = nx_read_dot(graph_path) G = nx.Graph(G) leavesoverlapremoval.remove_leaves_overlap(G) write_dot(G, outputpath)
# Main Flow
graph_path = sys.argv[1]
subgraph_path = sys.argv[2]
outputpath = sys.argv[3]
# Main Graph
input_subgraph_name = os.path.basename(subgraph_path)
subgraph_name = input_subgraph_name.split(".")[0]
# Sub Graph to be added
input_graph_name = os.path.basename(graph_path)
graph_name = input_graph_name.split(".")[1]
# Reading graph and subgraph
subG = nx_read_dot(subgraph_path)
nx.set_edge_attributes(subG, 'red', 'color')
G = nx_read_dot(graph_path)
pos = nx.get_node_attributes(G, 'pos')
nx.set_node_attributes(subG, pos, 'pos')
induced_G = nx.Graph(subG)
# print(nx.info(G))
print("saving in ", outputpath)
write_dot(induced_G, outputpath)
print("end")
# import betametrics/continuity as continuity
# import betametrics/drawing_highwayness
# import betametrics/speed_on_network as speed_on_network
# import betametrics/vertexangularresolution as vertexangularresolution
graphpath = sys.argv[1]
outputTxtFile = sys.argv[2]
input_file_name = os.path.basename(graphpath)
graph_name = input_file_name.split(".")[0]
Gpgv = pgv.AGraph(graphpath)
G = nx_read_dot(graphpath)
G = nx.Graph(G)
crossings_val = cr.count_crossings(G)
uniedgelen_val = -1;#uniedgelen.uniformity_edge_length(Gpgv)
stress_val = -1#st.stress(G)
neigpres_val = -1#neigpres.compute_neig_preservation(G)
labelsBBRatio_val = labelsmeas.labelsBBRatio(G)
totLabelsArea_val = labelsmeas.totLabelsArea(G)
bbox_val = othermeas.boundingBox(S)
crossings_str = "crossings: " + str(crossings_val)
uniformity_str = "uniformity edge length: "+ str(uniedgelen_val)
stress_str = "stress: "+ str(stress_val)
neigh_str = "neighbors preservation: " + str(neigpres_val)
import networkx as nx
from networkx.drawing.nx_agraph import write_dot
from networkx.drawing.nx_agraph import read_dot as nx_read_dot
import math
import stress as st
s_path = sys.argv[1]
g_path = sys.argv[2]
outputTxtFile = sys.argv[3]
input_file_name = os.path.basename(s_path)
graph_name = input_file_name.split(".")[0]
S = nx_read_dot(s_path)
G = nx_read_dot(g_path)
G=sorted(nx.connected_component_subgraphs(G), key=len, reverse=True)[0]
S_induced = nx.Graph(G.subgraph(S))
stress_val_S = st.stress(S)
stress_val_SG = st.stress(S, G)
stress_val_SGI = st.stress(S, S_induced)
output_txt = "Metrics for " + graph_name + "\n"
output_txt += "stress_S:" + str(stress_val_S) + "\n"
outputpath = sys.argv[3]
print("add subcomponent: input ", graphpath, subgraphpath, outputpath)
# Main Graph
input_graph_name = os.path.basename(graphpath)
graph_name = input_graph_name.split(".")[0]
print(graph_name)
# Sub Graph to be added
input_subgraph_name = os.path.basename(subgraphpath)
subgraph_name = subgraphpath.split(".")[0]
# Reading graph and subgraph
G = nx_read_dot(graphpath)
nx.set_edge_attributes(G, 'red', 'color')
SubG = nx_read_dot(subgraphpath)
commonVertices = set(set(G.nodes()) & set(SubG.nodes()))
avg_edge_length = avg_edge_length(G)
if len(crossings.count_crossings_single_graph(G)):
print(graph_name + " has crossings.")
print("exiting")
sys.exit()
v_counter = 0
for commonVertex in commonVertices:
v_counter += 1
l = l.split('"')
u = l[1]
v = l[3]
G.add_edge(u, v)
f.close()
return G
org_to_alphanum, alphanum_to_org = None, None
# check trees
for fname in file_name:
if folder_name == "TopicsLayersData":
G = read_txt_file(folder_name + '/' + fname)
else:
G = nx_read_dot(folder_name + '/' + file_name)
org_to_alphanum, alphanum_to_org = create_alphanum_dict(G)
if not nx.is_connected(G):
print("not connected:", fname)
quit()
cycle = None
try:
cycle = nx.find_cycle(G)
except:
pass
if not cycle == None:
print("Found cycle in ", fname)
quit()
if folder_name == "TopicsLayersData":
G = read_txt_file(folder_name + '/' + file_name[levels - 1])
import pygraphviz as pgv
import networkx as nx
from networkx.drawing.nx_agraph import write_dot
from networkx.drawing.nx_agraph import read_dot as nx_read_dot
# Main Flow
graph_path = sys.argv[1]
tree_path = sys.argv[2]
outputpath = tree_path #sys.argv[3]
input_graph_name = os.path.basename(graph_path)
graph_name = input_graph_name.split(".")[1]
G=nx_read_dot(graph_path)
G=nx.Graph(G)
T=nx_read_dot(tree_path)
T=nx.Graph(T)
weight_V_info=nx.get_node_attributes(G, 'weight')
label_V_info=nx.get_node_attributes(G, 'label')
width_V_info=nx.get_node_attributes(G, 'width')
heigth_V_info=nx.get_node_attributes(G, 'height')
level_V_info=nx.get_node_attributes(G, 'level')
# pos_V_info=nx.get_node_attributes(G, 'pos')
fontname_V_info=nx.get_node_attributes(G, 'fontname')
fontsize_V_info=nx.get_node_attributes(G, 'fontsize')
import sys
import os
import pygraphviz as pgv
import networkx as nx
from networkx.drawing.nx_agraph import write_dot
from networkx.drawing.nx_agraph import read_dot as nx_read_dot
g_path = sys.argv[1]
h_path = sys.argv[2]
outputpath = sys.argv[3]
g_name = os.path.basename(g_path).split(".")[0]
# Reading graph and subgraph
G = nx_read_dot(g_path)
G = nx.Graph(G)
H = nx_read_dot(h_path)
H = nx.Graph(H)
glevels = nx.get_node_attributes(G, "level")
glabels = nx.get_node_attributes(G, 'label')
gfontsize = nx.get_node_attributes(G, "fontsize")
gweight = nx.get_node_attributes(G, "weight")
gwidth = nx.get_node_attributes(G, "width")
gheight = nx.get_node_attributes(G, "height")
gfontname = nx.get_node_attributes(G, "fontname")
levels_n = {}
id_n = {}
