def compare_algorithms(test_maze):
algo_comparison_df = pd.DataFrame(columns=column_name_list)
# BFS
maze = copy.deepcopy(test_maze)
result_dict = bfs_traversal(maze, len(maze))
path = maze_runner.get_path(dim - 1, dim - 1, maze)
df_entry = pd.DataFrame(
[(len(path), result_dict["total_steps"],
result_dict["max_fringe_length"], result_dict["avg_fringe_length"])],
columns=column_name_list,
index=['BFS'])
algo_comparison_df = algo_comparison_df.append(df_entry)
# DFS
maze = copy.deepcopy(test_maze)
result_dict = dfs_traversal(maze, len(maze))
path = maze_runner.get_path(dim - 1, dim - 1, maze)
df_entry = pd.DataFrame(
[(len(path), result_dict["total_steps"],
result_dict["max_fringe_length"], result_dict["avg_fringe_length"])],
columns=column_name_list,
index=['DFS'])
algo_comparison_df = algo_comparison_df.append(df_entry)
# BD-BFS
maze = copy.deepcopy(test_maze)
result_dict = bd_bfs(maze, len(maze))
df_entry = pd.DataFrame(
[(result_dict["path_length"], result_dict["total_steps"],
result_dict["max_fringe_length"], result_dict["avg_fringe_length"])],
columns=column_name_list,
index=['BD-BFS'])
algo_comparison_df = algo_comparison_df.append(df_entry)
# a-star with manhattan heuristic
maze = copy.deepcopy(test_maze)
result_dict = a_star_traversal(maze, "manhattan")
path = maze_runner.get_path(dim - 1, dim - 1, maze)
df_entry = pd.DataFrame(
[(len(path), result_dict["total_steps"],
result_dict["max_fringe_length"], result_dict["avg_fringe_length"])],
columns=column_name_list,
index=['astar_manhattan'])
algo_comparison_df = algo_comparison_df.append(df_entry)
# a-star with euclidian heuristic
maze = copy.deepcopy(test_maze)
result_dict = a_star_traversal(maze, "euclidian")
path = maze_runner.get_path(dim - 1, dim - 1, maze)
df_entry = pd.DataFrame(
[(len(path), result_dict["total_steps"],
result_dict["max_fringe_length"], result_dict["avg_fringe_length"])],
columns=column_name_list,
index=['astar_euclidian'])
algo_comparison_df = algo_comparison_df.append(df_entry)
return algo_comparison_df
def test_a_star(dim, p):
test_maze = maze_runner.get_maze(dim, p)
# a-star with manhattan heuristic
maze = copy.deepcopy(test_maze)
manhattan_result_dict = a_star_traversal(maze, "manhattan")
if manhattan_result_dict["is_solvable"]:
path = maze_runner.get_path(dim - 1, dim - 1, maze)
print "Path", path
print "Length of path: ", len(path)
maze_runner.trace_path(maze, path)
else:
maze_runner.visualize_maze(maze)
# a-star with euclidian heuristic
maze = copy.deepcopy(test_maze)
euclidian_result_dict = a_star_traversal(maze, "euclidian")
if euclidian_result_dict["is_solvable"]:
path = maze_runner.get_path(dim - 1, dim - 1, maze)
print "Path", path
print "Length of path: ", len(path)
maze_runner.trace_path(maze, path)
else:
maze_runner.visualize_maze(maze)
def source_dist(x, y, maze):
path = maze_runner.get_path(x, y, maze)
return len(path)
if fringe_len>max_fringe_length: max_fringe_length = fringe_len avg_fringe_length = avg_fringe_length + (fringe_len - avg_fringe_length)/exploration_steps closed_set.add((x,y)) # Spreads fire to the neighboring cell as mentioned in the question. Since we might have # more cells on fire, the boundary_cells also get updated maze, boundary_cells = spread_fire(maze, dim, q, boundary_cells) fringe = update_fringe_using_boundary_cells(fringe, maze, boundary_cells) # No Solution return 0, exploration_steps, max_fringe_length, avg_fringe_length, closed_set, -1, -1 # Main code dim = 30 p = 0.22 q = 0.2 maze = mr.get_maze(dim, p) mr.visualize_maze(maze) manhattan_result, manhattan_steps, manhattan_max_fringe_length, manhattan_avg_fringe_length, manhattan_closed_set, x_cord, y_cord = fire_traversal(maze, q) mr.visualize_maze(maze) if manhattan_result == 1: print "Solution found" path = mr.get_path(dim-1, dim-1, maze) mr.trace_path(maze, path) elif manhattan_result == 0: print "Solution not found" mr.visualize_maze(maze) else: print "Burnt at " + str(x_cord) + ", " + str(y_cord) maze[x_cord][y_cord].value = 1.5 path = mr.get_path(x_cord, y_cord, maze) mr.trace_path(maze, path)
def bd_bfs(maze, dim):
fringe1 = deque()
fringe2 = deque()
closed1 = []
closed2 = []
fringe1.append((0, 0))
fringe2.append((dim - 1, dim - 1))
maze[0][0].parent = None
maze[dim - 1][dim - 1].parent = None
max_fringe_length = 0
avg_fringe_length = 0
exploration_steps = 0
result = 0
while len(fringe1) != 0 and len(fringe2) != 0:
current1 = fringe1.popleft()
exploration_steps = exploration_steps + 1
m1 = current1[0]
n1 = current1[1]
if current1 not in closed1:
if maze[m1][n1].value != 1:
intersect1 = CheckNeighbours_BBFS.checkneighbours_bbfs(
maze, m1, n1, dim, fringe1, closed1)
if intersect1 is not None:
# print "Intersecting node 1:", intersect1
result = 1
break
closed1.append((m1, n1))
current2 = fringe2.popleft()
exploration_steps = exploration_steps + 1
m2 = current2[0]
n2 = current2[1]
if current2 not in closed2:
if maze[m2][n2].value != 1:
intersect2 = CheckNeighbours_BBFS.checkneighbours_bbfs(
maze, m2, n2, dim, fringe2, closed2)
if intersect2 is not None:
# print "Intersecting node 2:", intersect2
result = 1
break
closed2.append((m2, n2))
closed_set = closed1 + closed2
fringe_length = len(fringe1) + len(fringe2)
avg_fringe_length = avg_fringe_length + (
fringe_length - avg_fringe_length) / exploration_steps
if fringe_length > max_fringe_length:
max_fringe_length = fringe_length
if result == 0:
result_dict = {
"is_solvable": False,
"total_steps": exploration_steps,
"max_fringe_length": max_fringe_length,
"avg_fringe_length": avg_fringe_length,
"closed_set": closed_set
}
return result_dict
else:
path1 = []
path2 = []
if intersect1 is not None:
path1 = maze_runner.get_path(current1[0], current1[1], maze)
while intersect1[0] <= dim - 1 and intersect1[1] <= dim - 1:
path2.append(intersect1)
if intersect1 == (dim - 1, dim - 1):
break
intersect1 = maze[intersect1[0]][intersect1[1]].parent
# maze_runner.trace_path_bbfs(maze, path1, path2)
elif intersect2 is not None:
path1 = maze_runner.get_path(intersect2[0], intersect2[1], maze)
while current2[0] <= dim - 1 and current2[1] <= dim - 1:
path2.append(current2)
if current2 == (dim - 1, dim - 1):
break
current2 = maze[current2[0]][current2[1]].parent
# maze_runner.trace_path_bbfs(maze, path2, path1)
# print path
# print len(path)
result_dict = {
"is_solvable": True,
"total_steps": exploration_steps,
"max_fringe_length": max_fringe_length,
"avg_fringe_length": avg_fringe_length,
"closed_set": closed_set,
"path_length": len(path1) + len(path2)
}
return result_dict
from cell import Cell
import maze_runner as mr
from dfs import dfs_traversal
import copy
maze = []
for row in xrange(15):
maze.append([])
for col in xrange(15):
maze[row].append(Cell(0))
maze[0][1].value = 1
for col in range(2, 15, 1):
maze[5][col].value = 1
maze[6][2].value = 1
for col in range(2, 15, 1):
maze[11][col].value = 1
maze[12][2].value = 1
mr.visualize_maze(maze)
result = dfs_traversal(maze, 15)
path = mr.get_path(14, 14, copy.deepcopy(maze))
print path
mr.trace_path(copy.deepcopy(maze), path)
fringe = result["fringe"]
print result["max_fringe_length"]
mr.visualize_explored_cells(copy.deepcopy(maze), fringe)