def testSetAndGetWeight(self):
"""
Testing set&gets methods of NodeData's weight
"""
node1 = NodeData()
node1.setWeight(8)
self.assertEqual(8, node1.getWeight())
def test_as_dict_node(self):
pos = (1, 2, 3)
node1 = NodeData(1, pos, 3.4)
node_dict = node1.as_dict_node()
test_dict = {"id": 1, "pos": pos, "_weight": 3.4, "_tag": 0, "_info": "f", "_src": {}, "_dest": {}}
for k, v in node_dict.items():
self.assertEqual(v, test_dict[k])
def testSetAndGetTagB(self):
"""
Testing set&gets methods of NodeData's tagB
"""
node1 = NodeData()
node1.setTagB(10)
self.assertEqual(10, node1.getTagB())
def __dijkstra(self, start_node: NodeData, dest_node: NodeData):
"""
This method marks on each vertex the distance to the source vertex and
@return path - Dict[int, NodeData] that the shortest path from start_node
"""
nodes = self.__graph.get_all_v()
q = PriorityQueue()
path: Dict[int, NodeData] = dict()
q.put(start_node)
for n in nodes.values():
node: NodeData = n
node.set_weight(math.inf)
node.set_info("WHITE")
path[n.get_key()] = None
start_node.set_weight(0)
while not q.empty():
v: NodeData = q.get()
if v.get_info() == "WHITE":
v.set_info("GRAY")
else:
continue
if v.get_key() == dest_node.get_key():
return path
for k, w in self.__graph.all_out_edges_of_node(
v.get_key()).items():
n: NodeData = nodes[k]
if n.get_info() == "WHITE":
weight = v.get_weight() + w
if weight < n.get_weight():
q.put(n)
n.set_weight(weight)
path[n.get_key()] = v
v.set_info("BLACK")
return path
def testSetDub(self):
"""
This function tests the setDub function in NodeData
"""
node1 = NodeData()
node1.setDub(3)
self.assertEqual(3, node1.dub)
def setCounter(self):
"""
This function tests the setConuter function in NodeData.
"""
node1 = NodeData()
node1.setCounter(300)
self.assertEqual(node1.counter, 300)
def test_creatingNewNodeAndGetKey(self):
"""
Test that we can create a new NodeData. and get it's key (in the beginning should be 0).
"""
# creating a new node
newNode = NodeData()
print("key of node is", newNode.getKey())
self.assertEqual(0, newNode.getKey())
def test_getMC(self):
g0 = DiGraph()
node0 = NodeData(0, (0, 1, 2))
node1 = NodeData(1, (2.4, 7.1, 3.5))
g0.add_node(node0.getkey())
g0.add_node(node1.getkey())
g0.add_edge(node0.getkey(), node1.getkey(), 7)
g0.remove_edge(node0.getkey(), node1.getkey())
self.assertEqual(g0.get_mc(), 4)
def test_get_all_v(self):
graph = DiGraph()
graph.add_node(1)
graph.add_node(2)
nodes = graph.get_all_v()
self.assertEqual(len(nodes.values()), 2, 'not all nodes returned')
self.assertEqual(nodes.get(1), NodeData(1),
'Doesn\'t contain all nodes')
self.assertEqual(nodes.get(2), NodeData(2),
'Doesn\'t contain all nodes')
def test_set_location(self):
n1 = NodeData(0, (1, 2, 3))
assert (1, 2, 3) == n1.getLocation()
n1.setLocation((4, 2, 4))
assert (4, 2, 4) == n1.getLocation()
n1.setLocation(None)
assert (4, 2, 4) == n1.getLocation()
def setUp(self):
global n, n1, n2
n = NodeData(5)
n1 = NodeData(2)
n2 = NodeData(4)
n.addNi(n1, 4.4)
n.addNi(n2, 9.4)
n.tag = 1
n.info = "b"
n.myLocation = (1, 1, 1)
def test_remove_node(self):
graph = DiGraph()
graph.add_node(1)
graph.add_node(2)
graph.add_node(3)
graph.add_edge(1, 2, 1)
graph.add_edge(1, 3, 1)
self.assertEqual(graph.e_size(), 2)
self.assertEqual(graph.v_size(), 3)
graph.remove_node(1)
self.assertEqual(graph.e_size(), 0)
self.assertEqual(graph.v_size(), 2)
self.assertEqual(graph.get_all_v().get(1), None)
self.assertEqual(graph.get_all_v(), {2: NodeData(2), 3: NodeData(3)})
def test__copy__(self):
n1 = NodeData(0)
n2 = n1.__copy__()
assert n1.comper(n2)
n1 = NodeData(0, (0, 1, 2))
n2 = n1.__copy__()
assert n1.comper(n2)
def test_get_edge_weight(self):
pos = (1, 2, 3)
node = NodeData(1, pos, 3.4)
node.add_dest(1, 3.2)
node.add_dest(2, 3.2)
node.add_dest(3, 4.5)
node.add_dest(4, 1.3)
node.add_dest(5, 3.4)
node.add_dest(6, 2.3)
test_dict = {'1': None, '2': 3.2, '3': 4.5, '4': 1.3, '5': 3.4, '6': 2.3}
for k, v in test_dict.items():
self.assertEqual(node.getWeight(int(k)), v)
def test_get_and_set_info(self):
node: NodeData = NodeData(1, (20, 30, 40))
self.assertTrue(node.get_info() == "")
node.set_info("black")
self.assertTrue(node.get_info() == "black")
node.set_info("white")
self.assertTrue(node.get_info() == "white")
def test_set_and_get_weight_(self):
for i in range(100):
weight = random.uniform(0, 50)
node: NodeData = NodeData(i, (20, 30, 40))
self.assertTrue(node.get_weight() == 0)
node.set_weight(weight)
self.assertTrue(node.get_weight() == weight)
def test_connected_components(self):
self.graph = DiGraph()
for i in range(5):
self.graph.add_node(i)
# 0 <-> 1
self.graph.add_edge(0, 1, 1)
self.graph.add_edge(1, 0, 1.1)
# 2
self.graph.add_edge(1, 2, 1.3)
# 3 <-> 4
self.graph.add_edge(4, 3, 1.1)
self.graph.add_edge(3, 4, 1.1)
algo = GraphAlgo(self.graph)
scc: list = algo.connected_components()
self.assertTrue(scc.__contains__([NodeData(2)]))
self.assertTrue(scc.__contains__([NodeData(0), NodeData(1)]))
self.assertTrue(scc.__contains__([NodeData(3), NodeData(4)]))
def add_node(self, node_id: int, pos: tuple = None) -> bool:
if self.__nodes.get(node_id) is None:
self.__nodes.__setitem__(node_id, NodeData(node_id, pos))
self.__edges.__setitem__(node_id, {})
self.__edges_into.__setitem__(node_id, {})
self.__mc += 1
return True
return False
def add_node(self, node_id: int, pos: tuple = None) -> bool:
if node_id not in self.graph and node_id >= 0:
n = NodeData(node_id, pos)
self.graph[node_id] = n
self.neighborsSrc[node_id] = {}
self.neighborsDest[node_id] = {}
self.MC += 1
return True
return False
def test_get_pos(self):
for j in range(100):
key = random.uniform(0, 50)
key_int = int(key)
x = random.uniform(50, 100)
y = random.uniform(50, 100)
z = random.uniform(50, 100)
node: NodeData = NodeData(key_int, (x, y, z))
self.assertTrue(node.get_pos() == (x, y, z))
def test_get_all_v(self):
graph = DiGraph()
tuple0 = (0, 30, 2)
tuple1 = (50, 50, 50)
node0 = NodeData(0, tuple0) # node: key=0 tuple=(0, 30, 2)
node1 = NodeData(2, tuple0) # node: key=2 tuple=(0, 30, 2)
node2 = NodeData(10, tuple1) # node: key=10 tuple=(50, 50, 50)
graph.add_node(node0.get_key(), tuple0)
graph.add_node(node1.get_key(), tuple0)
graph.add_node(node2.get_key(), tuple1)
nodes = [node0, node1, node2]
for node in nodes:
self.assertIn(node, graph.get_all_v().values())
def test_has_src(self):
pos = (1, 2, 3)
node = NodeData(1, pos, 3.4)
node.add_src(1, 3.2)
node.add_src(2, 3.2)
node.add_src(3, 4.5)
node.add_src(4, 1.3)
test_list = [1, 2, 3, 4, 5]
for k in test_list:
if k == 1 or k == 5:
self.assertEqual(node.has_src(k), False)
else:
self.assertEqual(node.has_src(k), True)
def test_AddNode(self):
g0 = DiGraph()
node0 = NodeData(0, (0, 1, 2))
node1 = NodeData(1, (2.4, 7.1, 3.5))
g0.add_node(node0.getkey())
g0.add_node(node1.getkey())
self.assertEqual(g0.v_size(), 2)
def add_node(self, node_id: int, pos: tuple = None) -> bool:
if node_id not in self.nodes: #If the vertex you want to add is not found at all
self.nodes[node_id] = NodeData(
node_id,
pos) #Create a new vertex and add it to the list of vertices
self.edges[node_id] = {
"IN": {},
"OUT": {}
} # Adding the outgoing and incoming edges of the vertex we added
self.modeCount += 1
return True
return False
def add_node(self, node_id: int, pos: tuple = None) -> bool:
"""
This function adds a node to the graph.
@param node_id: The node ID
@param pos: The position of the node
@return: True if the node was added successfully, False o.w.
"""
if not self._vertexes.__contains__(node_id):
self._vertexes[node_id] = NodeData(node_id, pos)
self._MC += 1
return True
else:
return False
def dijkstra(start: NodeData, key_to_find: int, graph: GraphInterface):
start.set_dist(0)
# counter for how many visited
visited = set()
# using tuple here so the values won't change
unvisited_queue = [(start.get_dist(), start.get_key())]
heapq.heapify(unvisited_queue)
while len(unvisited_queue) and len(visited) != graph.v_size():
current_node: int = heapq.heappop(unvisited_queue)[1]
if current_node not in visited:
visited.add(current_node)
if key_to_find == current_node:
return
for dest, w in graph.all_out_edges_of_node(current_node).items():
if (w + graph.get_all_v().get(current_node).get_dist()) < graph.get_all_v().get(dest).get_dist():
graph.get_all_v().get(dest).set_dist(w + graph.get_all_v().get(current_node).get_dist())
graph.get_all_v().get(dest).set_parent(current_node)
unvisited_queue.append(
(graph.get_all_v().get(dest).get_dist(), dest))
heapq.heapify(unvisited_queue)
def test_initGraph(self):
g0 = DiGraph()
node0 = NodeData(0, (0, 1, 2))
node1 = NodeData(1, (2.4, 7.1, 3.5))
g0.add_node(node0.getkey())
g0.add_node(node1.getkey())
g1 = GraphAlgo(g0)
self.assertEqual(g0.v_size(), g1.graph.v_size())
def test_removeNode(self):
g0 = DiGraph()
node0 = NodeData(0, (0, 1, 2))
node1 = NodeData(1, (2, 7, 3))
g0.add_node(node0.getkey())
g0.add_node(node1.getkey())
g0.remove_node(0)
self.assertEqual(g0.v_size(), 1)
def test_add_src(self):
pos = (1, 2, 3)
node = NodeData(1, pos, 3.4)
node.add_src(1, 3.2)
node.add_src(2, 3.2)
node.add_src(3, 4.5)
node.add_src(4, 1.3)
node_dict = node.get_src()
self.assertEqual(1 in node_dict, False)
test_dict = {'2': 3.2, '3': 4.5, '4': 1.3}
for k, v in node_dict.items():
self.assertEqual(v, test_dict[str(k)])
def __encoder(self):
"""
This method help to building a json object in our format.
note: use in the save function.
"""
dict_nodes = self.get_graph().get_all_v()
dic = {
"Edges": [],
"Nodes":
[NodeData.encoder(node) for node in list(dict_nodes.values())]
}
for node in dict_nodes.keys():
for dest, w in self.__graph.all_out_edges_of_node(node).items():
dic["Edges"].append({"src": node, "w": w, "dest": dest})
return dic
