def make_planar(G):
if planarity.is_planar(G.edges()):
return G
all_kuratowski_edges = []
next_G = G.copy()
while planarity.is_planar(G.edges()) == False:
edge_list = planarity.kuratowski_edges(G)
print(len(edge_list))
G.remove_edges_from(edge_list)
for edge in edge_list:
all_kuratowski_edges.append(edge)
itr = 0
replaced = []
for edge in all_kuratowski_edges:
neighbors = nx.neighbors(G, edge[1])
if itr < len(neighbors) and edge not in replaced:
G.add_edge(edge[0], neighbors[itr])
elif itr >= len(neighbors) and edge not in replaced:
global neighbors
neighbors = nx.neighbors(G, edge[0])
itr = 0
itr = itr + 1
print(planarity.is_planar(G), nx.number_of_edges(G))
print(planarity.is_planar(next_G), nx.number_of_edges(next_G))
import planarity
# Example of the complete graph of 5 nodes, K5
# K5 is not planar
# use text strings as labels
edgelist = [('a', 'b'), ('a', 'c'), ('a', 'd'), ('a', 'e'),
('b', 'c'),('b', 'd'),('b', 'e'),
('c', 'd'), ('c', 'e'),
('d', 'e')]
print planarity.is_planar(edgelist) # False
# print forbidden Kuratowski subgraph (K5)
print planarity.kuratowski_edges(edgelist)
# remove an edge
edgelist.remove(('a','b'))
# graph is now planar
print planarity.is_planar(edgelist) # True
# no forbidden subgraph, empty list returned
print planarity.kuratowski_edges(edgelist)
) # remove the first node and all its neighbours from the candidates
second_node = choice(list(possible_nodes))
G.add_edge(first_node, second_node, weight=1)
added_edges.append((first_node, second_node))
added_edges.append((second_node, first_node))
added_edges_node.append(first_node)
added_edges_node.append(second_node)
print(first_node, second_node)
nb += 1
pos = graphviz_layout(G, prog='sfdp')
nx.draw(G, pos, with_labels=False, node_size=1)
plt.show()
print(len(G.nodes()), planarity.is_planar(G.edges()))
itr = 1
while not planarity.is_planar(G.edges()):
K_edges = planarity.kuratowski_edges(G.edges())
nodes = nodes_in_K_graph(K_edges)
i = 0
for node in nodes:
for edge in G.edges(node):
if edge in K_edges or (edge[1], edge[0]) in K_edges:
G.remove_edge(edge[0], edge[1])
removed_edge.append((edge[0], edge[1]))
itr += 1
print(itr)
nb_of_edges_removed = 0
for edge in removed_edge:
G.add_edge(edge[0], edge[1])
def test_kuratowski_k5_function(self):
edges=planarity.kuratowski_edges(self.k5_edgelist)
assert_equal(sorted(edges),sorted(self.k5_edgelist))
def test_kuratowski_k5_function(self):
edges = planarity.kuratowski_edges(self.k5_edgelist)
assert_equal(sorted(edges), sorted(self.k5_edgelist))
def make_planar(G):
if planarity.is_planar(G.edges()):
print("Generated Graph is planar")
return G
removed_edge = []
itr = 0
G_copy = G.copy()
for edge in G_copy.edges():
G_copy.add_edge(edge[0], edge[1], weight=1)
print(len(G.edges()), planarity.is_planar(G.edges()))
while not planarity.is_planar(G):
K_edges = planarity.kuratowski_edges(G)
nodes = nodes_in_K_graph(K_edges)
for edge in K_edges:
if edge[0] in nodes or edge[1] in nodes:
G.remove_edge(edge[0], edge[1])
removed_edge.append((edge[0], edge[1]))
itr += 1
print("iterations", itr)
print("removed edges", len(removed_edge))
itr = 7
E_final = {}
for edge in removed_edge:
E_final[edge] = 0
while itr > 0:
X = Algebraic_Rank.get_algebraic_rank(G_copy, 0.5, 100)
E = {}
for edge in removed_edge:
E[edge] = abs(X[edge[0]] - X[edge[1]])
if (E_final[edge] < E[edge]):
E_final[edge] = E[edge]
itr -= 1
E_sorted = OrderedDict(
sorted(E_final.items(), key=lambda x: x[1], reverse=False))
for edge in E_sorted:
G.add_edge(edge[0], edge[1])
if planarity.is_planar(G):
del E_sorted[edge]
continue
else:
G.remove_edge(edge[0], edge[1])
start = time.time()
print("before rewiring", len(removed_edge))
for edge in E_sorted:
neigbors = G.neighbors(edge[1])
for neighbor in neigbors:
if not G.has_edge(edge[0], neighbor) and neighbor != edge[0]:
G.add_edge(edge[0], neighbor)
if planarity.is_planar(G):
del E_sorted[edge]
break
else:
G.remove_edge(edge[0], neighbor)
continue
else:
continue
for edge in E_sorted:
neigbors = G.neighbors(edge[0])
for neighbor in neigbors:
if not G.has_edge(edge[1], neighbor) and neighbor != edge[1]:
G.add_edge(edge[1], neighbor)
if planarity.is_planar(G):
del E_sorted[edge]
break
else:
G.remove_edge(edge[1], neighbor)
continue
else:
continue
end = time.time()
# run your code
elapsed = end - start
print("after first level rewiring", len(E_sorted))
print('time for first level rewiring: ', elapsed / 10, 'seconds')
start = time.time()
for edge in E_sorted:
edge_rewired = 0
neigbors = G.neighbors(edge[0])
for neighbor in neigbors:
neighbors_lvl_2 = G.neighbors(neighbor)
for neighbor_lvl_2 in neighbors_lvl_2:
if not G.has_edge(
edge[1], neighbor_lvl_2) and neighbor_lvl_2 != edge[1]:
G.add_edge(edge[1], neighbor_lvl_2)
if planarity.is_planar(G):
del E_sorted[edge]
edge_rewired += 1
break
else:
G.remove_edge(edge[1], neighbor_lvl_2)
continue
else:
continue
if edge_rewired > 0:
break
print("after first second level rewiring", len(E_sorted))
for edge in E_sorted:
neigbors = G.neighbors(edge[1])
edge_rewired = 0
for neighbor in neigbors:
neighbors_lvl_2 = G.neighbors(neighbor)
for neighbor_lvl_2 in neighbors_lvl_2:
if not G.has_edge(
edge[0], neighbor_lvl_2) and neighbor_lvl_2 != edge[0]:
G.add_edge(edge[0], neighbor_lvl_2)
if planarity.is_planar(G):
del E_sorted[edge]
edge_rewired += 1
break
else:
G.remove_edge(edge[0], neighbor_lvl_2)
continue
else:
continue
if edge_rewired > 0:
break
end = time.time()
# run your code
elapsed = end - start
print('time for second level rewiring: ', elapsed / 10, 'seconds')
print("after second level rewiring", len(E_sorted))
print(len(G.edges()), planarity.is_planar(G.edges()))
nx.write_adjlist(G, "Generated_planar_graph.edges")
pos = graphviz_layout(G, prog='sfdp')
nx.draw(G, pos, with_labels=False, node_size=1)
plt.show()
return G
