implemented bidirectional bfs

Author: rebmanop

algo.py

@@ -1,9 +1,10 @@
+from cell import Cell
 from grid import Grid
 from queue import PriorityQueue, Queue
 from utils import aborted, Heuristic
 
 
-def reconstruct_path(came_from, current) -> list: 
+def reconstruct_path(came_from, current) -> list[Cell]: 
     path = []
     while current in came_from:
         current = came_from[current]
@@ -13,7 +14,19 @@ def reconstruct_path(came_from, current) -> list:
     path.reverse() 
 
     #pop start cell from the path list, so animation wouldn't redraw it 
-    path.pop(0) 
+    if len(path) != 0:
+        path.pop(0) 
+    
+    return path
+
+
+def reconstruct_path_bbfs(came_from, current) -> list[Cell]: 
+    path = [current]
+    while current in came_from:
+        current = came_from[current]
+        path.append(current)
+
+    path.pop() 
 
     return path
 
@@ -128,6 +141,7 @@ def dijkstra(draw, grid, start, end, animation: bool) -> None:
             current.visit()
 
 
+
 def dfs(draw, grid, start, end, animation) -> None:
     marked = {cell: False for row in grid.raw_grid for cell in row}
     stack = [start]
@@ -191,6 +205,54 @@ def bfs(draw, grid, start, end, animation: bool)  -> None:
             current.visit()
 
 
+def bidirectional_bfs(draw, grid, start, end, animation: bool)  -> None:
+    Qf = Queue()
+    Qb = Queue()
+    explored_forward = {start}
+    explored_backwards = {end}
+    Qf.put(start)
+    Qb.put(end)
+    came_from_forward = {}
+    came_from_backwards = {}
+        
+    while not Qf.empty() and not Qb.empty():
+        if aborted():
+            return
+        
+        u = Qf.get()
+        v = Qb.get()
+
+        if u in explored_backwards:
+            path: list[Cell] = reconstruct_path(came_from_forward, u) + reconstruct_path_bbfs(came_from_backwards, u)
+            animate_path(draw, path, grid, animation)
+            return
+        
+        for neighbor in u.neighbors:
+            if neighbor not in explored_forward:
+                explored_forward.add(neighbor)
+                Qf.put(neighbor)
+                came_from_forward[neighbor] = u
+                if neighbor != end and neighbor != start:
+                    neighbor.make_open()
+
+        for neighbor in v.neighbors:
+            if neighbor not in explored_backwards:
+                explored_backwards.add(neighbor)
+                Qb.put(neighbor)
+                came_from_backwards[neighbor] = v
+                if neighbor != end and neighbor != start:
+                    neighbor.make_open()
+                
+        if animation:
+            draw()
+
+        if u != start and u != end:
+            u.visit()
+        
+        if v != end and v != start:
+            v.visit()
+            
+
 def gbfs(draw, grid: Grid, start, end, animation: bool):
     queue = PriorityQueue()
     visited = {start}
@@ -211,8 +273,7 @@ def gbfs(draw, grid: Grid, start, end, animation: bool):
             if neighbor not in visited:
                 count += 1
                 if neighbor.is_end():
-                    path = []
-                    path.append(current_cell)
+                    path = [current_cell]
                     while current_cell in came_from:
                         current_cell = came_from[current_cell]
                         path.append(current_cell)
@@ -233,3 +294,4 @@ def gbfs(draw, grid: Grid, start, end, animation: bool):
             draw()
 
 
+

grid.py

@@ -47,13 +47,13 @@ def update_neighbors_by_direction_for_every_cell(self) -> None:
                 cell.update_neighbors_by_direction(self.raw_grid)
 
 
-    def draw_under_grid_cells(self) -> None:
+    def draw_under_grid_lines(self) -> None:
         for row in self.raw_grid:
             for cell in row:
                 if not cell.is_wall():
                     cell.draw(self.win)
 
-    def draw_over_grid_cells(self) -> None:
+    def draw_over_grid_lines(self) -> None:
         for row in self.raw_grid:
             for cell in row:
                 if cell.is_wall(): 
@@ -93,6 +93,11 @@ def clear(self, start_end_except = False, barrier_except = False) -> None:
                         cell.reset()
 
 
+    def draw_grid_frame(self) -> None:
+        pygame.draw.line(self.win, GREY, ((self.x - 3, self.y)), (self.x - 3, self.y + self.height), width=5)
+        pygame.draw.line(self.win, GREY, ((self.x + self.width + 3, self.y)), (self.x + self.width + 3, self.y + self.height), width=5)
+        pygame.draw.line(self.win, GREY, ((0,self.y - 2)), (self.win.get_width(), self.y - 2), width=5)
+        pygame.draw.line(self.win, GREY, ((0, self.y + self.height + 2)), (self.win.get_width(), self.y + self.height + 2), width=5)
 
 
     def make_all_cells_wall(self) -> None:

gui_theme.json

@@ -34,17 +34,11 @@
          }
     },
 
-    "#legend_lable":
+    "@legend_cell_lables":
     {
         "colours":
          {
             "normal_text":"#45494e"
-         },
-        
-        "font_info_dict":
-         {
-            "size": "25"
          }
-
     }
  }

legend_cell.py

@@ -0,0 +1,19 @@
+import pygame
+from grid import Grid
+
+class LegendCell:
+    def __init__(self, win, x, y, color, frame_color, grid: Grid) -> None:
+        self.win = win
+        self.x = x
+        self.y = y
+        self.color = color
+        self.width, self.height = grid.gap, grid.gap
+        self.frame_color = frame_color
+        
+
+    def draw_legend_cell(self):
+        pygame.draw.rect(self.win, self.color, (self.x, self.y, self.width, self.height))
+        pygame.draw.line(self.win, self.frame_color, (self.x, self.y), (self.x,  + self.y + self.height))
+        pygame.draw.line(self.win, self.frame_color, (self.x + self.width, self.y), (self.x + self.width, self.y + self.height))
+        pygame.draw.line(self.win, self.frame_color, (self.x, self.y), (self.x + self.width, self.y))
+        pygame.draw.line(self.win, self.frame_color, (self.x, self.y + self.height), (self.x + self.width,  self.y + self.height))

main.py

@@ -1,12 +1,14 @@
 import os
-from typing import Callable
 import maze
 import algo
+import cell
 import pygame
 import pygame_gui
-from grid import Grid, GREY
-from cell import Cell
+from typing import Callable
 from strenum import StrEnum
+from grid import Grid, GREY
+from legend_cell import LegendCell
+from pygame_gui.core import ObjectID
 
 
 # """1:1  cell size = 16px"""
@@ -18,7 +20,6 @@
 # GRID_DIMENSIONS = (1680, 720) #px
 
 
-
 WIDTH, HEIGHT = 1291, 765
 GRID_WIDTH, GRID_HEIGHT = 1280, 680
 GRID_SIZE = (34, 64) #(rows, columns)
@@ -38,18 +39,16 @@
 pygame.display.set_icon(LOGO)
 
 
-def draw(win, grid, UI_MANAGER, time_delta) -> None:
+def draw(win, grid, UI_MANAGER, time_delta, legend_cells) -> None:
     win.fill(BG_COLOR)
-    grid.draw_under_grid_cells()
+    grid.draw_under_grid_lines()
     grid.draw_grid_lines()
-    grid.draw_over_grid_cells()
+    grid.draw_over_grid_lines()
     UI_MANAGER.update(time_delta)
-    
-    #grid frame lines
-    pygame.draw.line(win, GREY, ((grid.x - 3, grid.y)), (grid.x - 3, grid.y + grid.height), width=5)
-    pygame.draw.line(win, GREY, ((grid.x + grid.width + 3, grid.y)), (grid.x + grid.width + 3, grid.y + grid.height), width=5)
-    pygame.draw.line(win, GREY, ((0, grid.y - 2)), (WIDTH, grid.y - 2), width=5)
-    pygame.draw.line(win, GREY, ((0, grid.y + grid.height + 2)), (WIDTH, grid.y + grid.height + 2), width=5)
+    grid.draw_grid_frame()
+
+    for legend_cell in legend_cells:
+        legend_cell.draw_legend_cell()
 
     UI_MANAGER.draw_ui(WIN)
     pygame.display.update()
@@ -61,22 +60,22 @@ class Algorithms(StrEnum):
     DFS = "Depth-first Search" 
     BFS ="Breadth-first Search" 
     GBFS = "Greedy Best-first Search"
+    BBFS = "Bidirectional BFS"
 
 class Mazes(StrEnum):
     RECDIV = "Recursive Division Maze"
     RANDOM_DFS = "Randomized Depth-first Search Maze"
     SPIRAL = "Spiral Maze"
- 
 
 
 def main() -> None:
     clock = pygame.time.Clock()
     grid = Grid(WIN, GRID_SIZE, (GRID_WIDTH, GRID_HEIGHT), GRID_POSITION)
 
     #scales images to correct cell size
-    Cell.scale_cell_imgs(grid.gap, grid.gap)
+    cell.Cell.scale_cell_imgs(grid.gap, grid.gap)
 
-    draw_lambda = lambda: draw(WIN, grid, UI_MANAGER, time_delta)
+    draw_lambda = lambda: draw(WIN, grid, UI_MANAGER, time_delta, legend_cells)
 
 
     #gui elements initialization
@@ -108,11 +107,45 @@ def main() -> None:
         text='CE',
         manager=UI_MANAGER)
 
-    # legend_lable = pygame_gui.elements.UILabel(
-    #     relative_rect=pygame.Rect((grid.x, HEIGHT - 35), (100, 20)),
-    #     text="Legend: ",
-    #     manager=UI_MANAGER,
-    #     object_id="#legend_lable")
+    unvisited_cell_lable = pygame_gui.elements.UILabel(
+         relative_rect=pygame.Rect((grid.x + grid.gap, HEIGHT - 35), (130, grid.gap)),
+         text="-unvisited cell",
+         manager=UI_MANAGER,
+         object_id=ObjectID(class_id="@legend_cell_lables"))
+
+    visited_cell_lable = pygame_gui.elements.UILabel(
+         relative_rect=pygame.Rect((grid.x + 200 + grid.gap, HEIGHT - 35), (115, grid.gap)),
+         text="-visited cell",
+         manager=UI_MANAGER,
+         object_id=ObjectID(class_id="@legend_cell_lables"))
+
+    open_cell_lable = pygame_gui.elements.UILabel(
+         relative_rect=pygame.Rect((grid.x + 400 + grid.gap, HEIGHT - 35), (90, grid.gap)),
+         text="-open cell",
+         manager=UI_MANAGER,
+         object_id=ObjectID(class_id="@legend_cell_lables"))
+
+    path_cell_lable = pygame_gui.elements.UILabel(
+         relative_rect=pygame.Rect((grid.x + 600 + grid.gap, HEIGHT - 35), (90, grid.gap)),
+         text="-path cell",
+         manager=UI_MANAGER,
+         object_id=ObjectID(class_id="@legend_cell_lables"))
+
+    wall_cell_lable = pygame_gui.elements.UILabel(
+         relative_rect=pygame.Rect((grid.x + 800 + grid.gap, HEIGHT - 35), (90, grid.gap)),
+         text="-wall cell",
+         manager=UI_MANAGER,
+         object_id=ObjectID(class_id="@legend_cell_lables"))
+
+    legend_cells = [
+        LegendCell(WIN, grid.x, HEIGHT - 35, cell.UNVISITED_COLOR, GREY, grid),
+        LegendCell(WIN, grid.x + 200, HEIGHT - 35, cell.VISITED_COLOR, GREY, grid),
+        LegendCell(WIN, grid.x + 400, HEIGHT - 35, cell.OPEN_COLOR, GREY, grid),
+        LegendCell(WIN, grid.x + 600, HEIGHT - 35, cell.PATH_COLOR, GREY, grid),
+        LegendCell(WIN, grid.x + 800, HEIGHT - 35, cell.WALL_COLOR, GREY, grid)]
+
+    
+
 
     start = grid[grid.total_rows // 2][grid.total_columns // 2 - 2]
     end = grid[grid.total_rows // 2][grid.total_columns // 2 + 2]
@@ -128,7 +161,7 @@ def main() -> None:
 
     while running:
         time_delta = clock.tick(FPS)/1000.0
-        draw(WIN, grid, UI_MANAGER, time_delta)
+        draw(WIN, grid, UI_MANAGER, time_delta, legend_cells)
 
 
         for event in pygame.event.get():
@@ -258,26 +291,15 @@ def main() -> None:
     pygame.quit()
 
 
-# def set_default_position_for_points(start: list, end: list, grid: Grid):
-#     start[0].reset()
-#     end[0].reset()
-#     start[0] = grid[grid.total_rows // 2][grid.total_columns // 2 - 2]
-#     end[0] = grid[grid.total_rows // 2][grid.total_columns // 2 + 2]
-#     start[0].make_start()
-#     end[0].make_end()
-    
-
-
-
 def run_current_algorithm(
                         algo_menu: pygame_gui.elements.UIDropDownMenu, 
                         draw: Callable, 
                         grid: Grid, 
-                        start: Cell, 
-                        end: Cell, 
+                        start: cell.Cell, 
+                        end: cell.Cell, 
                         animation: bool) -> None:
 
-    """Calls funcion that visulizes selected algorithm"""
+    """Calls function that visulizes selected algorithm"""
 
     if algo_menu.selected_option  == Algorithms.ASTAR:
         algo.astar(draw, grid, start, end, animation) 
@@ -293,6 +315,9 @@ def run_current_algorithm(
 
     elif algo_menu.selected_option == Algorithms.GBFS:
         algo.gbfs(draw, grid, start, end, animation)
+
+    elif algo_menu.selected_option == Algorithms.BBFS:
+        algo.bidirectional_bfs(draw, grid, start, end, animation)
 
     else: 
         algo.astar(draw, grid, start, end, animation)
@@ -302,11 +327,11 @@ def generate_current_maze(
                         maze_menu: pygame_gui.elements.UIDropDownMenu, 
                         draw: Callable, 
                         grid: Grid, 
-                        start: Cell, 
-                        end: Cell, 
+                        start: cell.Cell, 
+                        end: cell.Cell, 
                         animation: bool) -> None:
 
-    """Calls funcion that generates selected maze"""
+    """Calls function that generates selected maze"""
 
     if maze_menu.selected_option == Mazes.RECDIV:
         maze.recursive_division_maze_gen(draw, grid, animation)