def test_get_degree(self):
self.g.add_oriented_connections([["A", "B"], ["B", "C"], ["D", "E"]])
self.assertEqual(1, self.g.get_degree(Node("A")))
self.assertEqual(2, self.g.get_degree(Node("B")))
self.assertEqual(1, self.g.get_degree(Node("C")))
self.assertEqual(1, self.g.get_degree(Node("D")))
self.assertEqual(0, self.g.get_degree(Node("F")))
def build_graph_from_source(self):
# Recieve all the string data from the file
file_list = str(self.graph_file).split("\n")
# Iterate over all parts of the file except for the last since that will be blank
for line in file_list[0:-1]:
# continue if there is a comment character in this line ignore it
if "#" in line:
continue
# split the line into from and to nodes
pair = line.split("\t")
to_node = int(pair[0])
from_node = int(pair[1])
# make the nodes if they do not exist
if to_node not in self.graph:
self.graph[to_node] = Node()
self.node_count += 1
if from_node not in self.graph:
self.graph[from_node] = Node()
self.node_count += 1
# add this edge
self.graph[to_node].add(from_node)
self.graph[from_node].add(to_node)
self.edge_count += 1
def test_add_not_oriented_connection(self):
self.g.add_not_oriented_connection(Node("A"), Node("B"))
self.assertTrue(self.g.is_connection("A", "B"))
self.assertTrue(self.g.is_connection("B", "A"))
self.assertFalse(self.g.is_connection("A", "C"))
with self.assertRaises(ValueError):
self.g.add_not_oriented_connection(Node("A"), Node("Z"))
def test_reachable_nodes(self):
self.assertEqual(1, len(self.g.reachable_nodes(Node("A"))))
self.g.add_not_oriented_connections([["A", "B"], ["B", "C"],
["D", "E"]])
self.assertEqual(3, len(self.g.reachable_nodes(Node("A"))))
self.assertEqual(2, len(self.g.reachable_nodes(Node("D"))))
self.assertEqual(1, len(self.g.reachable_nodes(Node("F"))))
class TestVectorMethods(unittest.TestCase):
n1 = Node(0)
n2 = Node(1)
def test_constructor(self):
vector = Vector((self.n1, self.n2), 0)
self.assertEqual(vector.endpoints_nodes, (self.n1, self.n2),
"failed constructor node set")
self.assertEqual(vector.weight, 0, "failed constructor weight")
def test_equal(self):
v1 = Vector((self.n1, self.n2), 0)
v2 = Vector((self.n1, self.n2), 0)
self.assertEqual(v1, v2, "failed equality")
def test_not_equal_weight(self):
v1 = Vector((self.n1, self.n2), 0)
v2 = Vector((self.n1, self.n2), 4)
self.assertNotEqual(v1, v2, "failed weight not equal")
def test_not_equal_direction(self):
v1 = Vector((self.n1, self.n2), 0)
v2 = Vector((self.n2, self.n1), 0)
self.assertNotEqual(v1, v2, "failed direction not equal")
def test_make_vector(self):
v1 = Vector.make_vector(self.n1, self.n2, 0)
v2 = Vector((self.n1, self.n2), 0)
self.assertEqual(v1, v2)
def testGetId(self): n1 = Node(0) n2 = Node(0) self.assertEqual(n1.getId(), n2.getId()) self.assertEqual(n1.getId(), 0) n2 = Node(1) self.assertNotEqual(n1.getId(), n2.getId())
def test_get_node_with_highest_degree(self):
self.g.add_oriented_connections([["A", "B"], ["B", "C"], ["F", "E"]])
self.assertEqual(Node("B"), self.g.get_node_with_highest_degree())
self.g.add_oriented_connections([["B", "A"], ["D", "E"]])
self.assertEqual(Node("B"), self.g.get_node_with_highest_degree())
self.g.add_oriented_connections([["D", "A"], ["A", "E"]])
self.assertEqual(Node("A"), self.g.get_node_with_highest_degree())
def test_get_pos(self):
id = 10
pos = (1, 2, 0)
node = Node(id)
node.setPos(pos)
x, y, z = node.getPos()
self.assertTrue(x == 1)
self.assertTrue(y == 2)
def __init__(self, screen):
self.screen = screen
self.running = True
self.tile = maptile()
self.node = Node(10, 10, 15, 30)
self.clock = pygame.time.Clock()
self.main_loop()
self.map_init()
def full_expression(self, depth, terminals):
if depth < self.max_depth:
operator = randint(0, len(self.functions) - 1)
return Node(self.functions[operator],
self.full_expression(depth + 1, terminals),
self.full_expression(depth + 1, terminals))
else:
value = terminals.pop(randint(0, len(terminals) - 1))
self.node_values.append(value)
return Node(value)
def test_get_node_with_lowest_value(self):
a = Node("A", "B", 3)
nodes = {a}
self.assertEqual(a, self.g.get_node_with_lowest_value(nodes))
b = Node("B", "C", 2)
nodes.add(b)
self.assertEqual(b, self.g.get_node_with_lowest_value(nodes))
c = Node("C", None, 0)
d = Node("D", None, None)
nodes.add(c)
nodes.add(d)
self.assertEqual(c, self.g.get_node_with_lowest_value(nodes))
class TestVectorSetMethods(unittest.TestCase):
# define useful testing nodes
parent_node = Node(0)
n1 = Node(1)
n2 = Node(2)
# define useful testing vectors
vP1 = Vector((parent_node, n1))
vP2 = Vector((parent_node, n2))
v12 = Vector((n1, n2))
def test_len_0(self):
vs = VectorSet(self.parent_node)
self.assertEqual(len(vs), 0)
def test_add(self):
vs = VectorSet(self.parent_node)
try:
vs.add(self.vP1)
except ValueError as ve:
self.fail(ve.args)
def test_add_repeat_vector(self):
vs = VectorSet(self.parent_node)
vs.add(self.vP1)
self.assertEqual(vs.add(self.vP1), False)
def test_len_same_after_failed_add(self):
vs = VectorSet(self.parent_node)
vs.add(self.vP1)
length = len(vs)
vs.add(self.vP1)
self.assertEqual(len(vs), length)
def test_remove_succeed(self):
vs = VectorSet(self.parent_node)
vs.add(self.vP1)
self.assertEqual(vs.remove(self.vP1), True)
def test_remove_failure(self):
vs = VectorSet(self.parent_node)
self.assertEqual(vs.remove(self.vP1), False)
def test_in_true(self):
vs = VectorSet(self.parent_node)
vs.add(self.vP1)
self.assertEqual(self.vP1 in vs, True)
def test_in_false(self):
vs = VectorSet(self.parent_node)
self.assertEqual(self.vP1 in vs, False)
def extract_nodes(edges):
node_ids = set()
for edge in edges:
node_ids.add(edge['source'])
node_ids.add(edge['target'])
nodes = []
for node_id in node_ids:
node = Node(node_id)
node.in_degree = count_in_degree(edges, node_id)
node.out_degree = count_out_degree(edges, node_id)
nodes.append(node)
return nodes
def add_node(self, node_id: int, pos: tuple = None):
if self.__Nodes.get(node_id) is None:
node = Node(node_id)
node.setPos(pos)
self.__Nodes.update({node_id: node})
self.__Edges.update({node_id: {}})
self.__allInEdges.update({node_id: {}})
self.__nodeSize += 1
self.__mc += 1
if node_id + 1 > self.__maxKey:
self.__maxKey = node_id + 1
return True
return False
def assert_dummy_vertices_get_correct_positions():
nodes = [Node('0'), Node('1')]
nodes[0].layer = 1
nodes[0].pos_in_layer = 1
nodes[1].layer = 2
nodes[1].pos_in_layer = 2
dummy_vertices = [Node('2'), Node('3'), Node('4')]
dummy_vertices[0].layer = 1
dummy_vertices[1].layer = 2
dummy_vertices[2].layer = 2
assign_positions_for_dummy_vertices(nodes, dummy_vertices)
return dummy_vertices[0].pos_in_layer == 2 \
and dummy_vertices[1].pos_in_layer == 3\
and dummy_vertices[2].pos_in_layer == 4
def bfs(self, node: Node, out: bool) -> list:
"""
BFS algorithm
Helper algorithm for the SCC algorithm.
:param node: - a node to start BFS searching from.
:param out: - determines how to search: out - search all out edges of node, in - search al in edges of node.
:return: - a list representing all visited nodes.
"""
for n in self.g.get_all_v().values(): # Set all nodes as unvisited.
n.temp_color = "WHITE"
visited = []
queue = []
node.temp_color = "GRAY"
visited.append(node.key)
queue.append(node.key)
if out:
while queue:
v = queue.pop(0)
for neighbor in self.g.all_out_edges_of_node(v).keys():
if self.g.get_all_v()[neighbor].temp_color == "WHITE":
self.g.get_all_v()[neighbor].temp_color = "GRAY"
visited.append(neighbor)
queue.append(neighbor)
else:
while queue:
v = queue.pop(0)
for neighbor in self.g.all_in_edges_of_node(v).keys():
if self.g.get_all_v()[neighbor].temp_color == "WHITE":
self.g.get_all_v()[neighbor].temp_color = "GRAY"
visited.append(neighbor)
queue.append(neighbor)
return visited
def start_search(self):
if self.maze.create_maze(
): # Verifica se conseguiu ler o arquivo e criar a matriz do labirinto
self.player = Player(self.maze.get_start(
)) # Posiciona o jogador no inicio do labirinto
self.root_node = Node(self.player.get_position(), None, 0,
0) # Cria o no raiz da árvore
self.calculate_cost(self.root_node)
self.opened_list.append(
self.root_node) # Adiciona o nó raiz na lista de abertos
success = False
while len(self.opened_list) != 0:
self.print_fluxograma()
current_node = self.opened_list.pop(
0) # Pega o primeiro nó da lista de abertos
self.player.set_position(current_node.get_position())
if not self.is_success(
current_node): # Se não for sucesso, explora esse nó
self.explore_node(current_node)
else:
success = True
print("------------- Final ---------------")
self.create_success_way(current_node)
print("\n O custo real eh: {}".format(
current_node.get_real_cost()))
print("\n A arvore gerada eh: ")
self.pprint_tree(self.root_node, "", True)
print("\n O caminho no labirinto sera: \n")
self.maze_solution()
break
if not success:
print('Não encontrou solução')
else:
print('Não foi possível criar o labirinto')
def split_edge(edge, node_to_layer_map, counter):
source = edge['source']
target = edge['target']
nodes = []
node_ids = [source]
for i in range(node_to_layer_map[source] + 1, node_to_layer_map[target]):
counter += 1
node = Node(str(counter))
node.layer = i
nodes.append(node)
node_ids.append(node.id)
node_ids.append(target)
edges = make_edges(node_ids)
return nodes, edges, counter
def add_node(self, node_id: int, pos: tuple = None) -> bool:
if node_id not in self.__graph.get('node') and node_id >= 0:
self.__graph.get('node').update({node_id: Node(node_id, pos)})
self.__mc = self.__mc + 1
return True
else:
return False
def test_get_neighbors(self):
self.g.add_not_oriented_connections([["A", "B"], ["B", "C"],
["D", "E"]])
self.assertEqual({Node("B")}, self.g.get_neighbors(Node("A")))
self.assertEqual({Node("A"), Node("C")},
self.g.get_neighbors(Node("B")))
self.assertEqual({Node("D")}, self.g.get_neighbors(Node("E")))
def test_remove_node(self):
self.g.add_not_oriented_connections([[Node("A"), Node("B")],
[Node("B"), Node("C")],
[Node("D"), Node("E")]])
self.g.remove_node(Node("B"))
self.assertEqual(5, len(self.g.nodes))
self.assertEqual(1, len(self.g.connections))
def add_node(self, node_id: int, pos: tuple = None) -> bool:
if node_id not in self.nodedict:
if pos is None:
pos = (random.random() * 40, random.random() * 40, 0.0)
n = Node(node_id, pos)
self.nodedict[node_id] = n
self.mc += 1
return True
return False
def hasNext(self, node: Node) -> bool: edges = self.graph.all_out_edges_of_node(node.getId()) s = [] for i in edges: if (not self.graph.get_node(i).getStatus()): s.append(i) if (len(s) != 0): return True return False
def test_get_hamilton_path_nodes(self):
self.g = Graph(["A", "B", "C", "D"])
connections = [["A", "B", 10], ["A", "C", 3], ["A", "D", 2],
["B", "C", 1], ["B", "D", 5], ["C", "D", 7]]
self.g.add_not_oriented_valued_connections(connections)
self.assertEqual(4, len(self.g.get_hamilton_path_nodes()))
self.assertIn(self.g.get_hamilton_path_nodes(),
[[Node("B"), Node("C"),
Node("A"), Node("D")],
[Node("A"), Node("D"),
Node("C"), Node("B")]])
def _next_line_todo(self, n_from: Node) -> Line:
tmp = []
attractiveness: float = 0
for line in n_from.lines:
if self._touched[line.get_next_id(n_from.position)] == 0:
attractiveness += line.attractiveness
tmp.append(line)
if len(tmp) == 0:
return n_from.find_by_id(self._map.start.ident)
tmp.sort()
def _fill_nodes(self):
nodes = {}
pos = 1
dx = self.GlobalData.W / (self.GlobalData.nW - 1)
dy = self.GlobalData.H / (self.GlobalData.nH - 1)
for i in range(0, self.GlobalData.nW):
for j in range(0, self.GlobalData.nH):
nodes[pos] = Node(i * dx, j * dy, self.GlobalData.t0)
pos += 1
return nodes
def test_get_leaving_edges_size(self):
self.g.add_not_oriented_connections([["A", "B"], ["B", "C"],
["D", "E"]])
self.assertEqual(1, self.g.get_leaving_edges_size(Node("A")))
self.assertEqual(2, self.g.get_leaving_edges_size(Node("B")))
self.assertEqual(1, self.g.get_leaving_edges_size(Node("C")))
self.assertEqual(0, self.g.get_leaving_edges_size(Node("F")))
self.g.add_oriented_connections([["C", "A"]])
self.assertEqual(1, self.g.get_leaving_edges_size(Node("A")))
self.assertEqual(2, self.g.get_leaving_edges_size(Node("B")))
self.assertEqual(2, self.g.get_leaving_edges_size(Node("C")))
self.assertEqual(0, self.g.get_leaving_edges_size(Node("F")))
def _set_nodes(self, nodes: int):
self._tmp = [[0 for _ in range(self._map.size[0])]
for _ in range(self._map.size[1])]
while len(self._map.nodes) != nodes:
new_coordinate = Coordinate.random_coordinate(
(SECURITY_ZONE, MAP_SIZE[0] - SECURITY_ZONE - 1),
(SECURITY_ZONE, MAP_SIZE[1] - SECURITY_ZONE - 1))
if self._check_node_place(new_coordinate):
self._map.nodes.append(
Node(len(self._map.nodes), new_coordinate))
self._tmp[new_coordinate.y][new_coordinate.x] = 1
def test_get_num_of_unique_neigbors(self):
self.g.add_not_oriented_connections([["A", "B"], ["B", "C"],
["D", "E"]])
self.assertEqual(1, self.g.get_num_of_unique_neigbors({Node("A")}))
self.assertEqual(0, self.g.get_num_of_unique_neigbors({Node("F")}))
self.assertEqual(2, self.g.get_num_of_unique_neigbors({Node("B")}))
self.assertEqual(
2, self.g.get_num_of_unique_neigbors({Node("A"),
Node("D")}))
self.assertEqual(
2,
self.g.get_num_of_unique_neigbors(
{Node("A"), Node("B"), Node("D")}))
def __convert_to_graph(self, data, dimension, points=[]):
nodes = [Node(i) for i in range(dimension)]
for i, costs in enumerate(data):
neighborhood = []
for j, cost in enumerate(costs):
neighborhood.append(Neighbor(node=nodes[j], cost=cost))
nodes[i].neighborhood = neighborhood
return nodes
