def main():
test_no = 0
# test case format: (my_car, other_cars, dimensions)
test_cases = [([(1, 2), (2, 2)], [[(4, 5), (5, 5)], [(4, 1), (4, 2),
(4, 3)],
[(2, 4), (2, 5)]], 5, (5, 2)),
([(3, 3), (3, 4)], [[(1, 2), (1, 3)], [(1, 5), (1, 6)],
[(2, 2), (3, 2)], [(1, 4), (2, 4)],
[(2, 6), (3, 6)], [(4, 6),
(5, 6)]], 6, (3, 6))]
for my_car, other_cars, dimensions, goal in test_cases:
test_no += 1
initial_state = (my_car, other_cars)
print("\nTest Case: %d, %s" % (test_no, initial_state))
root = ParkinglotNode(dimensions=dimensions,
goal=goal,
state=initial_state,
path=[])
print("Root Initial State: %s" % (str(root.state)))
print("Running A* using the Dominating Heuristic:")
print(
"Node: %s\n Total Nodes Examined: %d" %
(a_star(root, dominating_heuristic, cost_fn, node_count_max=5000)))
print("Running A* using the Dominated Heuristic:")
print(
"Node: %s\n Total Nodes Examined: %d" %
(a_star(root, dominated_heuristic, cost_fn, node_count_max=5000)))
del root
def main():
# test case structure: ([piles], n, counter)
test_cases = [([[], [], [4, 5, 1, 2, 6, 7, 10, 9, 3, 8]], 3, 10),
([[2, 11, 4], [3, 12, 6, 1], [7, 8, 9], [10, 5]], 4, 12)]
test_case = 0
for state, n, counter in test_cases:
test_case += 1
print("\nTest Case: %d, %s" % (test_case, state))
root = FreeCellNode(counter=counter, n=n,
state=state, path=[], root=True)
print("Running A* using the Dominating Heuristic:")
try:
print("Node: %s\n Total Nodes Examined: %d" %
(a_star(root, dominating_heuristic, cost_fn, node_count_max=15000)))
except TypeError:
print("No Solution Found.")
print("Running A* using the Dominated Heuristic:")
try:
print("Node: %s\n Total Nodes Examined: %d" %
(a_star(root, dominated_heuristic, cost_fn, node_count_max=15000)))
except TypeError:
print("No solution Found.")
del root
def __init__(self, maze_data, maze_tree, mazeinfo):
# initialize a dictionary for storing all step distances between
# significant points in the maze (all goals and the start)
self.dict = {}
# get all points to generate distances between
points = []
points.append((mazeinfo.startpx, mazeinfo.startpy))
for cur_point in range(0, len(mazeinfo.endpx)):
points.append(
(mazeinfo.endpx[cur_point], mazeinfo.endpy[cur_point]))
# generate step distances between all points in the points array and store
for start_point in range(0, len(points)):
start = points[start_point]
for end_point in range(0, len(points)):
maze_copy = []
maze_copy = createmaze.copy_maze(maze_data)
root_r = MazeTree.MazeTree()
maze_tree_copy = root_r.create_tree(maze_copy, mazeinfo,
mazeinfo.startpx,
mazeinfo.startpy)
end = points[end_point]
endx = []
endy = []
endx.append(end[0])
endy.append(end[1])
root = maze_tree_copy[start[0]][start[1]]
goal = (endx, endy)
val = search.a_star(maze_copy, mazeinfo, maze_tree_copy, root,
goal, False)
if (end, start) not in self.dict and end != start:
self.dict[(start, end)] = val[consts.STEPS_TAKEN_IDX()]
def calculate_path(self, treasure_pos):
if self.algorithm == "dfs":
return search.dfs(self.maze_grid, self.opponent_start_pos,
treasure_pos)
elif self.algorithm == "bfs":
return search.bfs(self.maze_grid, self.opponent_start_pos,
treasure_pos)
elif self.algorithm == "a_star":
return search.a_star(self.maze_grid, self.opponent_start_pos,
treasure_pos)
else:
return None
def update(g):
game = g
draw(game)
for event in pygame.event.get():
if event.type == pygame.QUIT:
game.running = False
elif event.type == pygame.MOUSEBUTTONDOWN:
game.dragging = True
pos = pygame.mouse.get_pos()
frame_radius = game.node_radius + 5
left, top = pos[0] - frame_radius, pos[1] - frame_radius
mousePos = pygame.Rect(left, top, frame_radius * 2, frame_radius * 2)
if game.creatingWalls:
mousePos = pygame.Rect(left, top, 50, 50)
check(mousePos, game)
elif event.type == pygame.MOUSEMOTION:
if game.dragging:
pos = pygame.mouse.get_pos()
frame_radius = game.node_radius + 5
left, top = pos[0] - frame_radius, pos[1] - frame_radius
mousePos = pygame.Rect(left, top, 50, 50)
check(mousePos, game)
elif event.type == pygame.MOUSEBUTTONUP:
game.dragging = False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_RETURN:
if game.creatingWalls:
for node in game.graph.nodes:
if node.isWall:
game.graph.adjacency[node.num, :] = 0
game.graph.adjacency[:, node.num] = 0
game.findingPath = True
game.graph = a_star(game.graph, update, game, alpha)
elif event.key == pygame.K_c:
return Game(cell_radius, rows, columns)
pygame.display.update()
game.clock.tick(60)
return game
def update(g):
game = g
draw(game)
for event in pygame.event.get():
if event.type == pygame.QUIT:
game.running = False
elif event.type == pygame.MOUSEBUTTONDOWN:
pos = pygame.mouse.get_pos()
chosenNode = check(pos, game)
if game.choosingStart:
chosenNode.isStart = True
elif game.choosingGoal:
chosenNode.isGoal = True
elif game.currentNode is not None and not game.currentNode == chosenNode:
game.graph.adjacency[game.currentNode.num, chosenNode.num] = 1
game.graph.adjacency[chosenNode.num, game.currentNode.num] = 1
game.currentNode = chosenNode
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_d: # d press
game.currentNode = None
elif event.key == pygame.K_s: # s press
game.choosingStart = True
elif event.key == pygame.K_g: # g press
game.choosingGoal = True
elif event.key == pygame.K_RETURN: # enter press
if game.graph.hasGoal and game.graph.hasStart:
game.findingPath = True # start finding path
game.graph = a_star(game.graph, update, game, 0.8)
elif event.key == pygame.K_c: # c press
return Game(10) # clear graph
elif event.type == pygame.KEYUP:
game.choosingStart = False
game.choosingGoal = False
pygame.display.update()
pathGame.clock.tick(60)
return game
def do_algorithm(self):
if self.treasure_set: # Can't find path to null position.
if self.algorithm == "dfs":
self.opponent_path = search.dfs(self.maze_grid, self.opponent_start_pos,
self.treasure_pos)
elif self.algorithm == "bfs":
self.opponent_path = search.bfs(self.maze_grid, self.opponent_start_pos,
self.treasure_pos)
elif self.algorithm == "a_star":
self.opponent_path = search.a_star(self.maze_grid, self.opponent_start_pos,
self.treasure_pos)
# Path is found
if self.opponent_path is not None:
self.path_started = True
# Already started so disable key.
# You might be surprised how important this is!
self.screen.onkey(None, "s")
self.start_or_continue_path()
else:
self.reset() # Goal unreachable.
def solve(args: argparse.Namespace) -> None:
problem_ = rules.EightPuzzle.initialize_random(
iterations=args.iterations,
width=args.width,
height=args.height)
print(problem_)
print("\nSearching for solution ..")
solution_ = search.a_star(problem_, heuristics.manhattan_distance)
print("\nFound following solution:")
print()
path = flatten_solution(solution_)
for action, state in path:
if action:
print(action.name)
print()
print(state)
print()
_, state = path[-1]
assert state.goal_test()
for event in pygame.event.get():
if event.type == pygame.QUIT:
done = True
if event.type == pygame.MOUSEBUTTONDOWN:
if event.button==1 and mouse_x<95 and mouse_x>45 and mouse_y>5 and mouse_y<35:
path = search.BFS()
if event.button==1 and mouse_x<215 and mouse_x>165 and mouse_y>5 and mouse_y<35:
path = search.DFS()
if event.button==1 and mouse_x<335 and mouse_x>285 and mouse_y>5 and mouse_y<35:
path = search.UCS()
if event.button==1 and mouse_x<450 and mouse_x>405 and mouse_y>5 and mouse_y<35:
path = search.a_star()
screen.fill(WHITE)
draw()
pygame.draw.rect(screen, GREY, [48,5,43,25])
pygame.draw.rect(screen, GREY, [168,5,43,25])
pygame.draw.rect(screen, GREY, [288,5,43,25])
pygame.draw.rect(screen, GREY, [408,5,40,25])
bfstext=font.render('BFS',True, BLACK)
dfstext=font.render('DFS',True, BLACK)
ucstext=font.render('UCS',True, BLACK)
astarttext=font.render('A*',True, BLACK)
parent = None
curr = None
try:
print('Testing start_goal')
(start, goal) = maps.gen_start_goal_pair(grid)
print('Testing Uniform Cost Search')
ucs = uniform_cost_search(grid, start, goal)
for (f, g, h, parent, curr) in ucs:
pass
print(g[goal])
# output_image(grid, "ucs.png", start, goal, path(parent, curr))
print('Testing A* Search')
astar = a_star(grid, start, goal, manhattan_distance_a)
for (f, g, h, parent, curr) in astar:
pass
print(g[goal])
# output_image(grid, "a_star.png", start, goal, path(parent, curr))
print('Testing A* Weighted Search')
astar_w = a_star(grid, start, goal, diagonal_distance_n, w=2)
for (f, g, h, parent, curr) in astar_w:
pass
print(g[goal])
# output_image(grid, "a_star_w.png", start, goal, path(parent, curr))
print('Writing to output file')
maps.output_file(grid, start, goal,
args.output_file + '_' + str(i) + '.txt')
def get_path(self, start, end):
results = search.a_star(self, start, end)
return results
# Create a graph based on the maze data
root = MazeTree.MazeTree()
maze_tree = root.create_tree(ascii_maze, mazeinfo, mazeinfo.startpx,
mazeinfo.startpy)
# Perform a search on the maze and export solution
if searchtype == "BFS":
NodesExp_StepsTaken = search.bredth_first(
ascii_maze, maze_tree[mazeinfo.startpx][mazeinfo.startpy], '.')
elif searchtype == "DFS":
NodesExp_StepsTaken = search.depth_first(
ascii_maze, maze_tree[mazeinfo.startpx][mazeinfo.startpy], '.')
elif searchtype == "GREEDY":
NodesExp_StepsTaken = search.greedy_first(
ascii_maze, maze_tree[mazeinfo.startpx][mazeinfo.startpy],
(mazeinfo.endpx, mazeinfo.endpy))
elif searchtype == "ASTAR" and len(mazeinfo.endpx) <= 1:
NodesExp_StepsTaken = search.a_star(
ascii_maze, mazeinfo, maze_tree,
maze_tree[mazeinfo.startpx][mazeinfo.startpy],
(mazeinfo.endpx, mazeinfo.endpy), True)
elif searchtype == "ASTAR" and len(mazeinfo.endpx) > 1:
NodesExp_StepsTaken = search.a_star(
ascii_maze, mazeinfo, maze_tree,
maze_tree[mazeinfo.startpx][mazeinfo.startpy],
(mazeinfo.endpx, mazeinfo.endpy), False)
# Output the maze solution to a specified location
outputname = input("Please enter the desired outputfile name (.txt): ")
createmaze.print_maze(ascii_maze, NodesExp_StepsTaken, outputname)
def dominated_heuristic(node):
return sum([len(pile) for pile in node.state])
if __name__ == "__main__":
# test case structure: ([piles], n, counter)
test_cases = [([[], [], [4, 5, 1, 2, 6, 7, 10, 9, 3, 8]], 3, 10)]
test_case = 0
for state, n, counter in test_cases:
test_case += 1
print("\nTest Case: %d" % (test_case))
root = FreeCellNode(counter=counter,
n=n,
state=state,
path=[],
root=True)
# print(root)
print("Running A* using the Dominating Heuristic:")
try:
print("Node: %s\n Total Nodes Examined: %d" %
(a_star(root, dominating_heuristic, cost_fn)))
except TypeError:
print("No Solution Found.")
continue
When running from the command line, compare every algorithm against
one of the tests.
"""
choice = sys.argv[1]
if choice not in {'little', 'big', 'random'}:
print('Usage: python3 test.py (little|big|random)')
start = (0, 0)
if choice == 'little':
grid = [[S, N, N, N], [N, M, M, M], [N, R, R, R], [N, N, N, G]]
goal = (3, 3)
elif choice == 'big':
grid = [[S, R, R, R, M, G], [N, R, R, R, M, N], [N, M, R, R, R, N],
[N, N, N, N, R, N], [N, R, N, N, N, N], [N, R, N, N, N, N]]
goal = (0, 5)
elif choice == 'random':
rows, cols = 10, 10
goal = (random.randint(0, rows - 1), random.randint(0, cols - 1))
types = (NORMAL, MOUNTAIN, RIVER)
grid = [[random.choice(types) for _ in range(rows)]
for _ in range(cols)]
grid[start[0]][start[1]] = START
grid[goal[0]][goal[1]] = GOAL
# Run each algorithm and visualize the result
print(visualize('BFS', grid, goal, bfs(grid, start, goal)))
print(visualize('DFS', grid, goal, dfs(grid, start, goal)))
print(visualize('Dijkstra’s algorithm', grid, goal, ucs(grid, start,
goal)))
print(visualize('A* search', grid, goal, a_star(grid, start, goal)))
[S, N, N, N],
[N, M, M, M],
[N, R, R, R],
[N, N, N, G]
]
goal = (3, 3)
elif choice == 'big':
grid = [
[S, R, R, R, M, G],
[N, R, R, R, M, N],
[N, M, R, R, R, N],
[N, N, N, N, R, N],
[N, R, N, N, N, N],
[N, R, N, N, N, N]
]
goal = (0, 5)
elif choice == 'random':
rows, cols = 10, 10
goal = (random.randint(0, rows-1), random.randint(0, cols-1))
types = (NORMAL, MOUNTAIN, RIVER)
grid = [[random.choice(types) for _ in range(rows)] for _ in range(cols)]
grid[start[0]][start[1]] = START
grid[goal[0]][goal[1]] = GOAL
# Run each algorithm and visualize the result
print(visualize('BFS', grid, goal, bfs(grid, start, goal)))
print(visualize('DFS', grid, goal, dfs(grid, start, goal)))
print(visualize('Dijkstra’s algorithm', grid, goal, ucs(grid, start, goal)))
print(visualize('A* search', grid, goal, a_star(grid, start, goal)))
tic = time.time()
bf_solution = bfs(m.start, m.goal_test, m.possible_next_locations)
toc = time.time()
if bf_solution is None:
print("Breadth-first search failed to find solution")
else:
bf_path = node_to_path(bf_solution)
m.mark_path(bf_path)
print("Path from BFS:")
print(" Path length: {}".format(len(bf_path)))
print(" Eval time: %.5f" % (toc - tic))
print(m)
m.clear_path()
heur = euclidean_distance(m.goal)
tic = time.time()
astar_solution = a_star(m.start, m.goal_test, m.possible_next_locations,
grid_cost, heur)
toc = time.time()
if astar_solution is None:
print("A* search failed to find a solution")
else:
astar_path = node_to_path(astar_solution)
m.mark_path(astar_path)
print("Path from A* (euclidean):")
print(" Path length: {}".format(len(astar_path)))
print(" Eval time: %.5f" % (toc - tic))
print(m)
m.clear_path()
heur = manhattan_distance(m.goal)
tic = time.time()
astar_solution = a_star(m.start, m.goal_test, m.possible_next_locations,
grid_cost, heur)