Flyod-Warshall algorithm, code cleanup.

Author: GurkNathe

README.md

@@ -41,6 +41,7 @@ After an algorithm has run:
 - <kbd>W</kbd>, <kbd>Left Click</kbd>, or <kbd>Right Click</kbd> to clear the Algorithm Mark-up
 
 While an algorithm is running:
+
 - Press <kbd>S</kbd> key to stop the algorithm
 
 ## Node Types
@@ -56,7 +57,7 @@ While an algorithm is running:
 ## Algorithm Progress
 
 ```
-Currently implemented algorithms (11/33):
+Currently implemented algorithms (12/33):
 
 - A*
 - Beam Search
@@ -66,6 +67,7 @@ Currently implemented algorithms (11/33):
 - B*
 - Depth First Search (DFS)
 - Dijkstra's Algorithms
+- Floyd-Warshall's algorithm
 - Greedy Best First Search (GBFS)
 - Random Walk
 - Theta*
@@ -86,7 +88,6 @@ Planned algorithms (Going to look at them):
 - Fast Iterative Method
 - Fast Marching Method
 - Fast Sweeping Method
-- Floyd-Warshall's algorithm
 - Fringe search
 
 - Greedy Best Line Search

main/Algorithms.py

@@ -6,6 +6,7 @@
 from algorithms.BStar import b_star
 from algorithms.DFS import dfs
 from algorithms.Dijkstra import dijkstra
+from algorithms.FloydWarshall import floyd_warshall
 from algorithms.GBFS import gbfs
 from algorithms.RandomWalk import rand_walk
 from algorithms.ThetaStar import theta_star
@@ -19,6 +20,7 @@
     "bstar",
     "dfs",
     "dijkstra",
+    "floyd",
     "gbfs",
     "rand",
     "theta",
@@ -52,6 +54,8 @@ def algorithm(self, algorithm):
                 dfs(self.draw, self.start, self.end)
             case "dijkstra":
                 dijkstra(self.draw, self.start, self.end)
+            case "floyd":
+                floyd_warshall(self.draw, self.start, self.end, self.grid)
             case "gbfs":
                 gbfs(self.draw, self.start, self.end)
             case "rand":

main/algorithms/AStar.py

@@ -1,6 +1,6 @@
 import pygame
 from queue import PriorityQueue
-from .RP import reconstruct_path, heuristic
+from .RP import reconstruct_path, heuristic, check
 
 
 def a_star(draw, grid, start, end):
@@ -20,11 +20,7 @@ def a_star(draw, grid, start, end):
     run = True
 
     while not open_set.empty() and run:
-        for event in pygame.event.get():
-            if event.type == pygame.QUIT:
-                pygame.quit()
-            if event.type == pygame.KEYDOWN and event.key == pygame.K_s:
-                run = False
+        run = check(pygame.event.get(), run)
 
         current = open_set.get()[2]
         open_set_hash.remove(current)

main/algorithms/BFS.py

@@ -1,6 +1,6 @@
 import pygame
 from queue import Queue
-from .RP import reconstruct_path
+from .RP import reconstruct_path, check, markup
 
 """
 1. Add root node to the queue, and mark it as visited(already explored).
@@ -24,24 +24,14 @@ def bfs(draw, start, end):
     run = True
 
     while nodes and not found and run:
-        for event in pygame.event.get():
-            if event.type == pygame.QUIT:
-                pygame.quit()
-            if event.type == pygame.KEYDOWN and event.key == pygame.K_s:
-                run = False
+        run = check(pygame.event.get(), run)
 
         current = nodes.pop(0)
 
         if current.is_checked():
             continue
 
-        if not current.is_start() and not current.is_end():
-            current.uncheck()
-
-        draw()
-
-        if not current.is_start() and not current.is_end():
-            current.check()
+        markup(draw, current)
 
         for neighbor in current.neighbors:
             if not neighbor.is_checked():

main/algorithms/BStar.py

@@ -1,7 +1,7 @@
 import pygame
 import random
 from queue import PriorityQueue
-from .RP import reconstruct_path, heuristic
+from .RP import reconstruct_path, heuristic, check
 
 
 def b_star(draw, grid, start, end):
@@ -21,11 +21,7 @@ def b_star(draw, grid, start, end):
     run = True
 
     while not open_set.empty() and run:
-        for event in pygame.event.get():
-            if event.type == pygame.QUIT:
-                pygame.quit()
-            if event.type == pygame.KEYDOWN and event.key == pygame.K_s:
-                run = False
+        run = check(pygame.event.get(), run)
 
         current = open_set.get()[2]
         open_set_hash.remove(current)

main/algorithms/BeamSearch.py

@@ -1,6 +1,6 @@
 import pygame
 import heapq
-from .RP import reconstruct_path, heuristic
+from .RP import reconstruct_path, heuristic, check, markup
 
 
 def beam_search(draw, start, end, beam_size):
@@ -14,11 +14,7 @@ def beam_search(draw, start, end, beam_size):
 
     # Continue searching until the beam is empty
     while beam and run:
-        for event in pygame.event.get():
-            if event.type == pygame.QUIT:
-                pygame.quit()
-            if event.type == pygame.KEYDOWN and event.key == pygame.K_s:
-                run = False
+        run = check(pygame.event.get(), run)
         # Take the most promising node from the beam
         _, current = heapq.heappop(beam)
 
@@ -28,13 +24,7 @@ def beam_search(draw, start, end, beam_size):
             end.make_end()
             break
 
-        if not current.is_start() and not current.is_end():
-            current.uncheck()
-
-        draw()
-
-        if not current.is_start() and not current.is_end():
-            current.check()
+        markup(draw, current)
 
         # Expand the node and add its children to the beam
         children = current.neighbors

main/algorithms/BellmanFord.py

@@ -1,6 +1,6 @@
 import pygame
 from queue import Queue
-from .RP import reconstruct_path, get_unvisited_nodes
+from .RP import reconstruct_path, get_unvisited_nodes, check, markup
 
 
 def bell_ford(draw, start, end, accuracy):
@@ -14,29 +14,14 @@ def bell_ford(draw, start, end, accuracy):
     run = True
 
     while counter >= 0 and run:
-        for event in pygame.event.get():
-            if event.type == pygame.QUIT:
-                pygame.quit()
-            if event.type == pygame.KEYDOWN and event.key == pygame.K_s:
-                run = False
+        run = check(pygame.event.get(), run)
 
         for current in nodes:
             if not run:
                 break
-            for event in pygame.event.get():
-                if event.type == pygame.QUIT:
-                    pygame.quit()
-                if event.type == pygame.KEYDOWN and event.key == pygame.K_s:
-                    run = False
-                    break
+            run = check(pygame.event.get(), run)
 
-            if not current.is_start() and not current.is_end():
-                current.uncheck()
-
-            draw()
-
-            if not current.is_start() and not current.is_end():
-                current.check()
+            markup(draw, current)
 
             for neighbor in current.neighbors:
                 if distance[current] + 1 < distance[neighbor]:

main/algorithms/BestFS.py

@@ -1,6 +1,6 @@
 import pygame
 from collections import deque
-from .RP import heuristic
+from .RP import heuristic, check, markup
 
 
 def get_checked_neighbors(node):
@@ -31,11 +31,7 @@ def best_fs(draw, start, end):
     run = True
 
     while len(queue) > 0 and run:
-        for event in pygame.event.get():
-            if event.type == pygame.QUIT:
-                pygame.quit()
-            if event.type == pygame.KEYDOWN and event.key == pygame.K_s:
-                run = False
+        run = check(pygame.event.get(), run)
 
         current = min(queue, key=lambda x: costs[x] + heuristic("manhattan", x, end))
         queue.remove(current)
@@ -45,14 +41,7 @@ def best_fs(draw, start, end):
             end.make_end()
             break
 
-        # Drawing stuff
-        if current != start:
-            current.uncheck()
-
-        draw()
-
-        if current != start:
-            current.check()
+        markup(draw, current)
 
         for neighbor in current.neighbors:
             cost = costs[current] + 1

main/algorithms/DFS.py

@@ -1,27 +1,5 @@
 import pygame
-from .RP import reconstruct_path
-
-"""
-Recursive
-1. Mark the current node as visited(initially current node is the root node)
-2. Check if current node is the goal, If so, then return it.
-3. Iterate over children nodes of current node, and do the following:
-    1. Check if a child node is not visited.
-    2. If so, then, mark it as visited.
-    3. Go to it's sub tree recursively until you find the goal node(In other words, do the same steps here passing the child node as the current node in the next recursive call).
-    4. If the child node has the goal node in this sub tree, then, return it.
-3. If goal node is not found, then goal node is not in the tree!
-
-
-Iterative
-1. Add root node to the stack.
-2. Loop on the stack as long as it's not empty.
-    1. Get the node at the top of the stack(current), mark it as visited, and remove it.
-    2. For every non-visited child of the current node, do the following:
-        1. Check if it's the goal node, If so, then return this child node.
-        2. Otherwise, push it to the stack.
-3. If stack is empty, then goal node was not found!
-"""
+from .RP import reconstruct_path, check, markup
 
 
 def dfs(draw, start, end):
@@ -32,25 +10,15 @@ def dfs(draw, start, end):
     run = True
 
     while len(stack) and not found and run:
-        for event in pygame.event.get():
-            if event.type == pygame.QUIT:
-                pygame.quit()
-            if event.type == pygame.KEYDOWN and event.key == pygame.K_s:
-                run = False
+        run = check(pygame.event.get(), run)
 
         current = stack.pop()
 
         if current.is_checked():
             continue
 
         # Drawing stuff
-        if current != start:
-            current.uncheck()
-
-        draw()
-
-        if current != start:
-            current.check()
+        markup(draw, current)
 
         # Find unvisited neighbors and check for end
         for neighbor in current.neighbors:

main/algorithms/Dijkstra.py

@@ -1,24 +1,7 @@
 import pygame
 from queue import PriorityQueue, Queue
-from .RP import reconstruct_path, get_unvisited_nodes
+from .RP import reconstruct_path, get_unvisited_nodes, check, markup
 
-"""
-Algorithm
-
-for each vertex in graph:
-    distance[vertex] = inf
-    if vertex != start, add vertex to Priority Queue (unvisited nodes)
-distance[start] = 0
-
-while the queue is not empty:
-    U = min from queue
-    for each unvisited neighbor vertex of U
-        tempDistance = distance[U] + edge_weight(U, vertex)
-        if tempDistance < distance[vertex]:
-            distance[vertex] = tempDistance
-            previous[vertex] = U
-
-"""
 
 # TODO: Refactor using a priority queue
 # Make distance a priority queue (node, inf)
@@ -36,11 +19,7 @@ def dijkstra(draw, start, end):
     run = True
 
     while unvisited_nodes and run:
-        for event in pygame.event.get():
-            if event.type == pygame.QUIT:
-                pygame.quit()
-            if event.type == pygame.KEYDOWN and event.key == pygame.K_s:
-                run = False
+        run = check(pygame.event.get(), run)
 
         # Choose node with smallest distance
         current_min = min(unvisited_nodes, key=distance.get)
@@ -53,19 +32,14 @@ def dijkstra(draw, start, end):
         for neighbor in current_min.neighbors:
             # Don't recheck for performance
             if not neighbor.is_checked():
-                if not neighbor.is_start() and not neighbor.is_end():
-                    neighbor.uncheck()
                 # edges between vertecies are not weighted
                 # (using constant weight of 1)
                 temp_value = distance[current_min] + 1
                 if temp_value < distance[neighbor]:
                     distance[neighbor] = temp_value
                     previous[neighbor] = current_min
 
-                draw()
-
-                if not neighbor.is_start() and not neighbor.is_end():
-                    neighbor.check()
+                markup(draw, neighbor)
 
         unvisited_nodes.remove(current_min)