Fixed B* (I think), removed Forbidden nodes.

GurkNathe · GurkNathe · commit 6d4925d20511 · 2023-01-23T17:05:19.000-08:00
diff --git a/README.md b/README.md
@@ -36,9 +36,8 @@ While an algorithm isn't running:
 - Press <kbd>Q</kbd> to exit
 - Press <kbd>C</kbd> to clear grid
 - Press <kbd>G</kbd> to generate a new maze
-- <kbd>Left Shift</kbd> + <kbd>Left Click</kbd> to place a forbbiden node after placing Start and End nodes
 - <kbd>Left Click</kbd> to place Start, then End, then Obstacles
-- <kbd>Right Click</kbd> to remove Start, End, Forbbiden nodes, or Obstacles
+- <kbd>Right Click</kbd> to remove Start, End, or Obstacles
 
 After an algorithm has run:
 
@@ -59,7 +58,6 @@ The testing will take longer as the visitable nodes increases. For my system, an
 - Start: where the search algorithm will start
 - End: where the search algorithm is trying to get to
 - Obstacle: a position the algorithms avoid
-- Forbidden: a position certain algorithms avoid (a different type of obstacle)
 - Check/Uncheck: markup for visualizing the algorithm
 - Path: markup for visualizing the found path
 - Default: a position that can be traversed
@@ -118,4 +116,8 @@ Planned algorithms (Going to look at them):
 - Viterbi algorithm
 
 - Yen's k-Shortest Paths
-```
+```
+
+Possible Incorrectly Implemented algorithms:
+
+- [B*](./resources/b_star.pdf)
diff --git a/main/Testing.py b/main/Testing.py
@@ -65,8 +65,8 @@ def __init__(self, *argv: list):
             wr = csv.writer(myfile, delimiter=',',
                             quotechar='|', quoting=csv.QUOTE_MINIMAL)
 
-            wr.writerow(['Algorithm', 'Local Run Time', 'Times Nodes Checked'])
-            algo_data: list = [['', '', len(get_unvisited_nodes(self.start))]]
+            wr.writerow(['Algorithm', 'Local Run Time', 'Times Nodes Checked', 'Path Length'])
+            algo_data: list = [['', '', len(get_unvisited_nodes(self.start)), '']]
 
             for alg in ALGORITHMS:
                 # Clear grid after every run
@@ -98,24 +98,10 @@ def __init__(self, *argv: list):
             wr.writerows(algo_data)
 
 
-    def get_num_nodes(self, start: object):
-        checked_nodes = []
-        to_check = [start]
-        num_nodes = 0
-        
-        while to_check:
-            print(to_check)
-            current = to_check.pop(0)
-            num_nodes += 1
-            for neighbor in current.neighbors:
-                if not neighbor in checked_nodes and neighbor not in to_check:
-                    to_check.append(neighbor)
-        return num_nodes
-
     def clear_grid(self, current_grid: list, rows: int, width: int):
         """
         Clear the grid by creating a new 2D list of Node objects,
-        keeping the start, end, obstacles and forbidden nodes from the
+        keeping the start, end, and obstacles nodes from the
         original grid.
 
         Parameters:
@@ -135,14 +121,13 @@ def clear_grid(self, current_grid: list, rows: int, width: int):
         for i in range(rows):
             grid.append([])
             for j in range(rows):
-                # If the current node is not the start, end, an obstacle or
-                # forbidden, create a new Node object for the current position
+                # If the current node is not the start, end, or an obstacle
+                # create a new Node object for the current position
                 # and add it to the grid
                 if (
                     not current_grid[i][j].is_start()
                     and not current_grid[i][j].is_end()
                     and not current_grid[i][j].is_obstacle()
-                    and not current_grid[i][j].is_forbidden()
                 ):
                     node = Node(i, j, node_width, rows)
                     grid[i].append(node)
diff --git a/main/algorithms/BStar.py b/main/algorithms/BStar.py
@@ -1,6 +1,28 @@
 import pygame
 from queue import PriorityQueue
-from .RP import reconstruct_path, heuristic, check
+from .RP import reconstruct_path, check
+
+# Manhattan distance
+def heuristic(node1: object, node2: object):
+    """
+    Calculate the Dynamic Manhattan distance between two nodes.
+
+    Parameters:
+        node1 (Node): The first node.
+        node2 (Node): The second node.
+
+    Returns:
+        int: The Dynamic Manhattan distance between the two nodes.
+    """
+    x1, y1 = node1.get_pos()
+    x2, y2 = node2.get_pos()
+    
+    blocked_penalty = len(node1.neighbors)
+    for node in node1.neighbors:
+        if not node.is_checked() and not node.is_unchecked():
+            blocked_penalty -= 1
+
+    return abs(x1 - x2) + abs(y1 - y2) + blocked_penalty
 
 
 def b_star(draw: object, grid: list, start: object, end: object):
@@ -27,7 +49,7 @@ def b_star(draw: object, grid: list, start: object, end: object):
     g_score = {node: float("inf") for row in grid for node in row}
     g_score[start] = 0
     f_score = {node: float("inf") for row in grid for node in row}
-    f_score[start] = heuristic("manhattan", start, end)
+    f_score[start] = heuristic(start, end)
 
     # Initialize a set to store the nodes in the open set
     open_set_hash = {start}
@@ -60,11 +82,10 @@ def b_star(draw: object, grid: list, start: object, end: object):
             if temp_g_score < g_score[neighbor]:
                 came_from[neighbor] = current
                 g_score[neighbor] = temp_g_score
-                f_score[neighbor] = temp_g_score + heuristic("manhattan", neighbor, end)
+                f_score[neighbor] = temp_g_score + heuristic(neighbor, end)
 
                 # Add the neighbor to the open set if it is not already there
-                # and the neighbor isn't marked as forbidden
-                if neighbor not in open_set_hash and not neighbor.is_forbidden():
+                if neighbor not in open_set_hash:
                     count += 1
                     open_set.put((f_score[neighbor], count, neighbor))
                     open_set_hash.add(neighbor)
diff --git a/main/node.py b/main/node.py
@@ -10,7 +10,6 @@
 START = COLORS.get("ORANGE")
 END = COLORS.get("TURQUOISE")
 PATH = COLORS.get("PURPLE")
-FORBID = COLORS.get("GREY")
 
 
 class Node:
@@ -67,9 +66,6 @@ def is_start(self):
     def is_end(self):
         return self.color == END
 
-    def is_forbidden(self):
-        return self.color == FORBID
-
     # Setting node states
     def check(self):
         """
@@ -107,9 +103,6 @@ def make_color(self, color: tuple):
         """
         self.color = color
 
-    def make_forbbiden(self):
-        self.color = FORBID
-
     def mult_check(self, dec: int):
         """
         Changes the color of a checked node that has been checked multiple times.
diff --git a/main/pathfinding.py b/main/pathfinding.py
@@ -37,7 +37,7 @@ def make_grid(rows: int, width: int):
 def clear_grid(current_grid: list, rows: int, width: int):
     """
     Clear the grid by creating a new 2D list of Node objects,
-    keeping the start, end, obstacles and forbidden nodes from the
+    keeping the start, end, and obstacles nodes from the
     original grid.
 
     Parameters:
@@ -57,14 +57,12 @@ def clear_grid(current_grid: list, rows: int, width: int):
     for i in range(rows):
         grid.append([])
         for j in range(rows):
-            # If the current node is not the start, end, an obstacle or
-            # forbidden, create a new Node object for the current position
-            # and add it to the grid
+            # If the current node is not the start, end, or an obstacle, create a new Node 
+            # object for the current position and add it to the grid
             if (
                 not current_grid[i][j].is_start()
                 and not current_grid[i][j].is_end()
                 and not current_grid[i][j].is_obstacle()
-                and not current_grid[i][j].is_forbidden()
             ):
                 node = Node(i, j, node_width, rows)
                 grid[i].append(node)
@@ -282,9 +280,6 @@ def main(argv: list):
                     end = node
                     end.make_end()
                 elif node != start and node != end:
-                    if pygame.key.get_mods() & pygame.K_LSHIFT:
-                        node.make_forbbiden()
-                    else:
                         node.make_obstacle()
 
             # Right mouse click
diff --git a/main/testing/BStar.py b/main/testing/BStar.py
@@ -1,5 +1,27 @@
 from queue import PriorityQueue
-from .RP import heuristic
+
+
+# Manhattan distance
+def heuristic(node1: object, node2: object):
+    """
+    Calculate the Dynamic Manhattan distance between two nodes.
+
+    Parameters:
+        node1 (Node): The first node.
+        node2 (Node): The second node.
+
+    Returns:
+        int: The Dynamic Manhattan distance between the two nodes.
+    """
+    x1, y1 = node1.get_pos()
+    x2, y2 = node2.get_pos()
+    
+    blocked_penalty = len(node1.neighbors)
+    for node in node1.neighbors:
+        if not node.is_checked() and not node.is_unchecked():
+            blocked_penalty -= 1
+
+    return abs(x1 - x2) + abs(y1 - y2) + blocked_penalty
 
 
 def b_star(grid: list, start: object, end: object):
@@ -25,7 +47,7 @@ def b_star(grid: list, start: object, end: object):
     g_score = {node: float("inf") for row in grid for node in row}
     g_score[start] = 0
     f_score = {node: float("inf") for row in grid for node in row}
-    f_score[start] = heuristic("manhattan", start, end)
+    f_score[start] = heuristic(start, end)
 
     # Initialize a set to store the nodes in the open set
     open_set_hash = {start}
@@ -54,11 +76,10 @@ def b_star(grid: list, start: object, end: object):
             if temp_g_score < g_score[neighbor]:
                 came_from[neighbor] = current
                 g_score[neighbor] = temp_g_score
-                f_score[neighbor] = temp_g_score + heuristic("manhattan", neighbor, end)
+                f_score[neighbor] = temp_g_score + heuristic(neighbor, end)
 
                 # Add the neighbor to the open set if it is not already there
-                # and the neighbor isn't marked as forbidden
-                if neighbor not in open_set_hash and not neighbor.is_forbidden():
+                if neighbor not in open_set_hash:
                     count += 1
                     open_set.put((f_score[neighbor], count, neighbor))
                     open_set_hash.add(neighbor)
diff --git a/main/testing/results/Generated_Maze-Example.csv b/main/testing/results/Generated_Maze-Example.csv
@@ -1,18 +1,18 @@
 Algorithm,Local Run Time,Times Nodes Checked
-,,1163
-astar,0.0019658000019262545,124
-beam,0.0003242999991925899,101
-bellford,1.1534317000005103,1352569
-bestfs,0.0008029999989958014,124
-bfs,0.0009060999982466456,679
-bisearch,0.00019459999748505652,358
-bstar,0.002126800001860829,124
-dfs,0.0013380999989749398,1120
-dijkstra,0.14483109999855515,713
-floyd,232.8206220000029,1574390316
-gbfs,0.0006450000000768341,101
-gbls,0.0008083000029728282,98
-ida,0.0016050999984145164,192
-iddfs,0.017313199998170603,16276
-lbfs,0.001781999999366235,2326
-rand,0.011425200002122438,11573
+,,1167
+astar,0.0030056999985390576,353
+beam,0.001310100000409875,400
+bellford,1.1081830999992235,1361889
+bestfs,0.002110999999786145,353
+bfs,0.0012076000002707588,1000
+bisearch,0.00026840000100492034,554
+bstar,0.003316300000733463,353
+dfs,0.0009766000002855435,846
+dijkstra,0.14303250000011758,1017
+floyd,245.82318180000038,1590686352
+gbfs,0.0020392000005813316,401
+gbls,0.00287439999920025,315
+ida,0.007990200001586345,1234
+iddfs,0.044287400000030175,36801
+lbfs,0.002202099998612539,2334
+rand,0.21115649999956076,230522
