def load_from_json(self, file_name: str) -> bool:
"""
This method loads graph from json file.
@param file_name: The path to the json file
@returns True if the loading was successful, else returns False
"""
try:
with open(file_name, "r") as file:
loaded_graph = DiGraph()
f = json.load(file)
for node in f.get("Nodes"):
id = node.get("id")
pos = None
if node.get("pos") is not None:
list_pos = node.get("pos").split(",")
x = float(list_pos[0])
y = float(list_pos[1])
z = float(list_pos[2])
pos = (x, y, z)
loaded_graph.add_node(id, pos)
for edge in f.get("Edges"):
src = edge.get("src")
dest = edge.get("dest")
w = edge.get("w")
loaded_graph.add_edge(src, dest, w)
self.graph = loaded_graph
except IOError as exp:
print(exp)
return False
return True
def test_getNode_getEdge(self):
print("test_getNode_getEdge")
graph = DiGraph()
graph.add_node(0)
graph.add_node(1)
graph.add_edge(0, 1, 1)
e = graph.getEdge(0, 1)
self.assertIsNotNone(e)
self.assertEqual(e.getSrc(), 0)
self.assertEqual(e.getDest(), 1)
self.assertEqual(e.getWeight(), 1)
n = graph.getNode(0)
self.assertIsNotNone(n)
self.assertEqual(n.getKey(), 0)
class GraphGenerator:
def __init__(self, vertices, edges):
self.graph = DiGraph()
self.v = vertices
self.e = edges
self.mc = 0
self.Generate()
def Generate(self) -> DiGraph:
i = 0
for vertex in range(self.v):
self.graph.add_node(
vertex, (random.uniform(0, 100), random.uniform(0, 100), 0))
while self.graph.e < self.e:
random_pair = (random.randrange(self.v), random.randrange(self.v),
random.uniform(0, 40))
source = random_pair[0]
destination = random_pair[1]
weight = random_pair[2]
self.graph.add_edge(source, destination, weight)
if i % 2 == 0:
self.graph.add_edge(destination, source, weight)
i = i + 1
return self.graph
def test_e_size(self):
graph = DiGraph()
for i in range(10):
graph.add_node(i)
for i in range(1, 10):
graph.add_edge(i - 1, i, 1.0)
self.assertEqual(9, graph.edge_size)
def graph_creator(v, e) -> DiGraph:
g = DiGraph()
for n in range(v):
g.add_node(n)
for i in range(0, v):
for j in range(1, v):
if g.e_size() < e:
g.add_edge(i, j, 10)
if g.e_size() >= e:
break
return g
def setUp(self) -> None:
graph = DiGraph()
self.graphTest = GraphAlgo(graph)
for n in range(6):
self.graphTest.graphAlgo.add_node(n)
self.graphTest.graphAlgo.add_edge(0, 1, 1)
self.graphTest.graphAlgo.add_edge(1, 0, 1.1)
self.graphTest.graphAlgo.add_edge(1, 2, 1.3)
self.graphTest.graphAlgo.add_edge(2, 3, 1.1)
self.graphTest.graphAlgo.add_edge(1, 3, 1.9)
self.graphTest.graphAlgo.add_edge(3, 4, 8)
self.graphTest.graphAlgo.add_edge(4, 5, 1.9)
self.graphTest.graphAlgo.add_edge(5, 2, 1.9)
def bfs(self, node_id: int, graph: DiGraph):
q = Queue()
n = graph.nodedict[node_id]
q.put(n)
n.set_tag(1)
while not q.empty():
node = q.get()
if node.key in graph.edgedict:
for key, w in graph.all_out_edges_of_node(node.key).items():
curr = graph.nodedict[key]
if curr.tag == 0:
q.put(curr)
curr.set_tag(1)
def test_path(self): # test path function
node = DiGraph.Node(0)
p = [1, 2, 3]
node.set_path(p)
np = node.get_path()
# check the node's path values
for i in range(len(np)):
self.assertEqual(p[i], np[i])
node.set_path()
p = list()
np = node.get_path()
for i in range(len(p)):
self.assertEqual(p[i], np[i])
def test_digraph(graph):
vertices = specify_vertices(graph)
edges = specify_edges(graph)
digraph = DiGraph(vertices, edges)
print(digraph)
digraph.adjacency_matrix()
sp = digraph.shortest_path("a","d",path=[])
n = digraph.neighbours_of("a")
iso = digraph.isolated_nodes()
c = digraph.is_connected()
print("A -> D : {0} \t Neighbours of A : {1} \t Isolated Nodes : {2} \t Is Connected : {3}".format(sp, n, [str(i) for i in iso], c))
def setUp(self) -> None:
self.g = DiGraph()
self.g1 = DiGraph()
for i in range(6):
self.g.add_node(i)
self.g1.add_node(i)
self.g.add_edge(1, 2, 1)
self.g.add_edge(1, 3, 1)
self.g.add_edge(1, 4, 1)
self.g.add_edge(2, 1, 1)
self.g.add_edge(2, 5, 1)
self.g.add_edge(3, 1, 1)
self.g.add_edge(4, 5, 1)
self.g.add_edge(4, 2, 1)
self.g1.add_edge(0, 1, 3)
self.g1.add_edge(0, 3, 7)
self.g1.add_edge(0, 4, 8)
self.g1.add_edge(1, 2, 1)
self.g1.add_edge(1, 3, 4)
self.g1.add_edge(3, 2, 2)
self.g1.add_edge(4, 3, 3)
def test_helper_scc(self):
g = DiGraph()
g.add_node(0)
g.add_node(1)
g.add_edge(0, 1, 3)
g.add_edge(1, 0, 3)
algo = GraphAlgo(g)
algo.bfs(0, 0)
def copy_graph(self) -> DiGraph:
g = DiGraph()
for node in self.__graph.get_all_v().values():
g.add_node(node.get_key(), node.get_pos())
for node in self.__graph.get_all_v():
for key, w in self.__graph.all_out_edges_of_node(node).items():
g.add_edge(node, key, w)
return g
def test_create_ten_power_four(self):
vertexes = 10**4
graph = DiGraph()
for i in range(vertexes):
x_random = random.uniform(35.18, 35.2)
y_random = random.uniform(32.1, 32.2)
graph.add_node(i, (x_random, y_random, 0.0))
for i in range(vertexes):
weight = random.uniform(0.0, 2.0)
if i != 0:
graph.add_edge(i, i - 1, weight)
graph.add_edge(i, i + 1, weight)
graph_algo = GraphAlgo(graph)
def reversegraph(self, graph):
newgraph = DiGraph()
for n in self.graph.NodeMap.keys():
newgraph.add_node(n)
for i in self.graph.NodeMap.keys():
for e in self.graph.all_out_edges_of_node(i).keys():
newgraph.add_edge(e, i, self.graph.all_out_edges_of_node(i).get(e))
return newgraph
def setUp(self) -> None:
graph = DiGraph()
for i in range(10):
graph.add_node(i)
for i in range(9):
graph.add_edge(i, i + 1, 3)
self.ga = GraphAlgo(graph)
def test_save_and_load_json(self):
"""
0<-1->2->3
1<-
"""
graph = DiGraph()
tuple0 = (0, 30, 2)
tuple1 = (50, 50, 50)
tuple2 = (20, 20, 20)
tuple3 = (30, 30, 30)
node0 = NodeData(0, tuple0)
node1 = NodeData(1, tuple1)
node2 = NodeData(2, tuple2)
node3 = NodeData(3, tuple3)
graph.add_node(node0.get_key(), tuple0)
graph.add_node(node1.get_key(), tuple1)
graph.add_node(node2.get_key(), tuple2)
graph.add_node(node3.get_key(), tuple3)
graph.add_edge(1, 2, 11)
graph.add_edge(2, 1, 11)
graph.add_edge(2, 3, 5)
graph.add_edge(1, 0, 3)
g_algo = GraphAlgo(graph)
g_algo.save_to_json("file1")
new_graph_algo = GraphAlgo(None)
new_graph_algo.load_from_json("file1")
same_graph = new_graph_algo
self.assertEqual(same_graph.get_graph(), new_graph_algo.get_graph())
self.assertEqual(new_graph_algo.get_graph(), g_algo.get_graph())
self.assertTrue(
new_graph_algo.get_graph() == g_algo.get_graph()) ##to ask
self.assertTrue(new_graph_algo.get_graph().get_mc() == 8)
self.assertTrue(new_graph_algo.get_graph().v_size() == 4)
self.assertTrue(new_graph_algo.get_graph().e_size() == 4)
def test_all_out_edges_of_node(self):
graph = DiGraph()
self.assertTrue(graph.add_node(0))
self.assertTrue(graph.add_node(1))
self.assertTrue(graph.add_node(2))
self.assertTrue(graph.add_node(3))
self.assertTrue(graph.add_edge(1, 2, 0))
self.assertTrue(graph.add_edge(2, 1, 1))
edge = graph.all_in_edges_of_node(1)
self.assertEqual(edge[2], 1)
edge = graph.all_in_edges_of_node(2)
self.assertEqual(edge[1], 0)
def test_shortest_path(self):
g0 = DiGraph()
node0 = NodeData(0, (0, 1, 2))
node1 = NodeData(1, (2.4, 7.1, 3.5))
node2 = NodeData(2, (1, 7, 8))
node3 = NodeData(3, (7, 1.3, 6.3))
g0.add_node(node0.getkey())
g0.add_node(node1.getkey())
g0.add_node(node2.getkey())
g0.add_node(node3.getkey())
g0.add_edge(0, 1, 1)
g0.add_edge(1, 2, 3)
g0.add_edge(2, 3, 4)
g0.add_edge(3, 0, 1)
g1 = GraphAlgo(g0)
dist, path = g1.shortest_path(0, 1)
self.assertEqual(dist, 1)
dist, path = g1.shortest_path(1, 3)
self.assertEqual(dist, 7)
def test_shortest_path_basic(self):
ga = GraphAlgo()
g0 = DiGraph()
r = rnd(x=3)
for n_id in range(3):
g0.add_node(n_id, (r.random() / 44, r.random() / 44))
g0.add_edge(0, 1, 1.2) # 0 --1.2-- 1
g0.add_edge(0, 2, 5) # \->5 /
g0.add_edge(1, 2, 3) # \ /-->3
ga.init(g0) # # 2
di, path = ga.shortest_path(0, 2)
# paint(g0, title='test_shortest_path_basic', show_w=True) # it's here for debug
self.assertEqual(di, 4.2)
self.assertEqual(path, [0, 1, 2])
def test_plot_graph(self):
p1 = (1.21, 2.12, 3.16)
p2 = (2.45, 4.16, 11.22)
p3 = (10.6, 3.12, 3.04)
# add nodes
self.graph = DiGraph()
self.graph.add_node(1, p1)
self.graph.add_node(2, p2)
self.graph.add_node(3, p3)
self.graph.add_node(4) # no pos given
# add edges
self.graph.add_edge(1, 2, 2)
self.graph.add_edge(2, 3, 3)
self.graph.add_edge(3, 4, 4)
self.graph.add_edge(4, 2, 9)
# init graph algo
self.algo = GraphAlgo()
self.algo.__init__(self.graph)
# print(self.algo.get_graph())
self.algo.create_graph()
class TestDiGraph(TestCase):
g = DiGraph()
for i in range(6):
g.add_node(i)
g.add_edge(0, 1, 2.5)
g.add_edge(1, 2, 1.5)
g.add_edge(1, 3, 4.5)
g.add_edge(2, 3, 1.5)
g.add_edge(2, 4, 3)
g.add_edge(3, 4, 3.3)
g.add_edge(4, 2, 2.7)
g.add_node(8)
g.add_node(9)
g.add_node(7)
g.add_edge(7, 8, 1.1)
g.add_edge(8, 9, 1.6)
g.remove_node(9)
g.remove_edge(7, 8)
# shortestPath(0,3) = (5.5,[0,1,2,3])
# connectedComponent = [[0],[1],[2,3,4]]
def test_v_size(self):
self.assertEqual(8, self.g.v_size())
def test_e_size(self):
self.assertEqual(9, self.g.e_size())
def test_all_in_edges_of_node(self):
i = self.g.all_in_edges_of_node(4)
self.assertEqual(i[2], 3)
self.assertEqual(i[3], 3.3)
def test_all_out_edges_of_node(self):
o = self.g.all_out_edges_of_node(0)
self.assertEqual(o[1], 2.5)
def test_get_mc(self):
self.assertEqual(self.g.get_mc(), 20)
def test_add_edge(self):
self.g.add_edge(4, 2, 2.8)
self.assertEqual(self.g.all_out_edges_of_node(4)[2], 2.7)
def test_remove_node(self):
b = 9 not in self.g.all_out_edges_of_node(8)
self.assertEqual(b, True)
def test_remove_edge(self):
b = 7 not in self.g.all_in_edges_of_node(8)
self.assertEqual(b,True)
def setUp(self):
# graph creator, |V|=7, |E|=18
self.graph = DiGraph()
for i in range(7):
self.graph.add_node(i)
self.graph.add_edge(0, 1, 1)
self.graph.add_edge(0, 2, 1)
self.graph.add_edge(0, 3, 1)
self.graph.add_edge(0, 4, 1)
self.graph.add_edge(0, 5, 1)
self.graph.add_edge(0, 6, 1)
self.graph.add_edge(1, 0, 1)
self.graph.add_edge(1, 2, 1)
self.graph.add_edge(2, 1, 1)
self.graph.add_edge(2, 4, 1)
self.graph.add_edge(3, 4, 1)
self.graph.add_edge(3, 5, 1)
self.graph.add_edge(4, 1, 1)
self.graph.add_edge(4, 2, 1)
self.graph.add_edge(4, 3, 1)
self.graph.add_edge(5, 0, 1)
self.graph.add_edge(5, 2, 1)
self.graph.add_edge(5, 4, 1)
def test_connected_components(self):
self.graph = DiGraph()
for i in range(8):
self.graph.add_node(i)
# 0-1-2
self.graph.add_edge(0, 1, 5)
self.graph.add_edge(1, 2, 2.3)
self.graph.add_edge(2, 0, 1.9)
# 3
self.graph.add_edge(2, 3, 1.3)
# 4->5->6->7
self.graph.add_edge(4, 5, 5.5)
self.graph.add_edge(5, 6, 3.2)
self.graph.add_edge(6, 7, 4.5)
self.graph.add_edge(7, 4, 1.8)
algo = GraphAlgo(self.graph)
list_temp = algo.connected_components()
list_actual = [[4, 5, 6, 7], [0, 1, 2], [3]]
self.assertEqual(list_temp, list_actual)
count_scc: list_temp = algo.connected_components()
self.assertTrue(count_scc.__contains__([0, 1, 2]))
self.assertTrue(count_scc.__contains__([3]))
self.assertTrue(count_scc.__contains__([4, 5, 6, 7]))
def test_time_bigGraph(self):
start = time.time()
graph = DiGraph()
for i in range(10000):
graph.add_node(i, (i, i + 1, i + 2))
for j in range(100):
graph.add_edge(j, j + 1, 3)
end = time.time()
self.assertTrue((end - start) < 10, "it's too much time!!")
def test_all_out_edges_of_node(self):
graph = DiGraph()
self.assertTrue(graph.add_node(2))
self.assertTrue(graph.add_node(3))
self.assertTrue(graph.add_node(4))
self.assertTrue(graph.add_edge(2, 3, 0))
self.assertTrue(graph.add_edge(3, 4, 1))
edge = graph.all_out_edges_of_node(3)
self.assertEqual(edge[3], 1)
def reversed_copy(self) -> DiGraph:
g = DiGraph()
for node in self.get_graph().nodedict:
g.add_node(node)
for node in g.nodedict:
if node in self.get_graph().edgedict:
for ni in self.get_graph().all_out_edges_of_node(node):
g.add_edge(ni, node, 0)
return g
def test_init_graph(self):
print("test_init_graph")
graph = DiGraph()
mc = graph.get_mc()
edges = graph.get_edges()
nodes = graph.get_nodes()
edge_size = graph.e_size()
node_size = graph.v_size()
self.assertEqual(mc, 0)
self.assertEqual(edge_size, 0)
self.assertEqual(node_size, 0)
self.assertIsInstance(edges, dict)
self.assertIsInstance(nodes, dict)
def test_connected_components(self):
p = (1.21, 2.12, 3.16)
# add nodes
self.graph = DiGraph()
self.graph.add_node(1, p)
self.graph.add_node(2, p)
self.graph.add_node(3, p)
self.graph.add_node(4, p)
# add edges
self.graph.add_edge(1, 2, 2)
self.graph.add_edge(2, 3, 3)
self.graph.add_edge(3, 4, 4)
self.graph.add_edge(4, 2, 9)
# init graph algo
self.algo = GraphAlgo()
self.algo.__init__(self.graph)
# connected_components
self.assertEqual([[1], [2, 3, 4]], self.algo.connected_components())
# connected_components(id)
self.assertEqual([3, 4, 2], self.algo.connected_component(3))
def setUp(self) -> None:
self.graph = DiGraph()
for vertex in range(5):
self.graph.add_node(vertex)
self.graph.add_edge(0, 1, 2)
self.graph.add_edge(1, 2, 1)
self.graph.add_edge(1, 4, 6)
self.graph.add_edge(2, 3, 2)
self.graph.add_edge(3, 4, 1)
self.algo = GraphAlgo(self.graph) # init
###########
self.g = DiGraph()
for vertex in range(8):
self.g.add_node(vertex)
self.g.add_edge(0, 1, 0)
self.g.add_edge(1, 2, 0)
self.g.add_edge(2, 3, 0)
self.g.add_edge(3, 0, 0)
self.g.add_edge(2, 4, 0)
self.g.add_edge(4, 5, 0)
self.g.add_edge(5, 6, 0)
self.g.add_edge(6, 4, 0)
self.g.add_edge(6, 7, 0)
self.algo2 = GraphAlgo(self.g) # init
def transpose(self) -> None:
"""
Transpose this graph: for every edge (u,v) make it (v,u)
this is part of the algorithm of finding connected component
:return:None
"""
graph = DiGraph()
for i in self.g.get_all_v().keys():
node = self.g.getnode(i)
graph.add_node(i, node.getlocation())
graph.getnode(i).settag(node.gettag())
for i in self.g.get_all_v().keys():
for n, w in self.g.all_out_edges_of_node(i).items():
graph.add_edge(n, i, w)
self.g = graph
def setUp(self) -> None:
self.graph = DiGraph()
self.graph.add_node(1)
self.graph.add_node(2)
self.graph.add_node(3)
self.graph.add_node(4)
self.graph.add_node(5)
self.graph.add_node(6)
self.graph.add_node(7)
self.graph.add_node(8)
self.graph.add_node(9)
self.graph.add_node(10)
self.graph.add_edge(1, 2, 1.5)
self.graph.add_edge(1, 3, 3)
self.graph.add_edge(2, 4, 2)
self.graph.add_edge(3, 2, 4.3)
self.graph.add_edge(4, 3, 9)
self.graph.add_edge(4, 1, 5)
self.graph.add_edge(5, 6, 3)
self.graph.add_edge(6, 8, 7.1)
self.graph.add_edge(8, 5, 9)
self.graph.add_edge(9, 10, 3)
self.graph.add_edge(10, 9, 5.8)
self.graph_algo = GraphAlgo(self.graph)
def design_graph_object(graph, G = None):
"""
Create the DiGraph object without creating a list
param:
----------------
graph(dict) : Dictionary graph format,
G(DiGraph) : DiGraph object (It doesn't belong to Networkx library)
return:
----------------
G(DiGraph) : Object returning
"""
if (not G):
G = DiGraph()
for node in graph.keys():
if (node not in G.get_vertices()):
G.add_node(node)
for ng in graph[node]:
if (ng not in G.get_vertices()):
G.add_node(ng)
G.add_edge(node,ng)
return G
