Major refactoring, package preparation and maze unittesting

Author: pablogsal

a_star/__init__.py

@@ -1 +1,3 @@
 __author__ = 'Pablo Galindo Salgado'
+
+from .a_star import a_star,Node,DijkstraHeap

a_star/a_star.py

@@ -88,7 +88,7 @@ def a_star(graph, start, end):
 
         current_node = frontier.pop()
 
-        if not current_node or current_node.point == end:
+        if not current_node: #or current_node.point == end:
             return frontier
 
         for neighbor in graph.neighbors( current_node.point ):

a_star/tools.py

@@ -0,0 +1,102 @@
+
+class SquareGrid():
+
+    def __init__(self, width, height):
+        self.width = width
+        self.height = height
+        self.walls = set()
+
+    def is_inside(self, point):
+        """ Helper function to know if a given point is inside the Grid.
+
+            :param point: Tuple of two ints
+            :return: Boolean
+        """
+        x, y = point
+        return 0 <= x < self.width and 0 <= y < self.height
+
+    def is_wall(self, point):
+        """ Helper function to know if a given point is a wall.
+
+            :param point: Tuple of two ints
+            :return: Boolean
+        """
+        return point not in self.walls
+
+    def neighbors(self, point):
+        """ Yields the valid neighbours of a given point.
+
+            :param point: Tuple of two ints
+            :return: Generator of tuples of ints
+        """
+
+        x, y = point
+        candidates = [(x + 1, y), (x, y - 1), (x - 1, y), (x, y + 1)]
+        candidates = filter(self.is_inside, candidates)
+        candidates = filter(self.is_wall, candidates)
+        yield from candidates
+
+    def _draw_tile(self, point, style, width):
+        """ Returns a symbol for the current point given the style dictionary and the drawing width.
+
+            :param point: Tuple of two ints
+            :param style: Hash map of the form (int,int) : int or (int,int) : (int,int)
+            :param width: Integer representing the width of the graph
+            :return: string (character)
+        """
+
+        character = "."
+        if 'number' in style and point in style['number']:
+            character = "%d" % style['number'][point]
+        if 'point_to' in style and style['point_to'].get(point, None) is not None:
+            (x1, y1) = point
+            (x2, y2) = style['point_to'][point]
+            if x2 == x1 + 1:
+                character = "\u2192"
+            if x2 == x1 - 1:
+                character = "\u2190"
+            if y2 == y1 + 1:
+                character = "\u2193"
+            if y2 == y1 - 1:
+                character = "\u2191"
+        if 'start' in style and point == style['start']:
+            character = "S"
+        if 'goal' in style and point == style['goal']:
+            character = "E"
+        if 'path' in style and point in style['path']:
+            character = "@"
+        if point in self.walls:
+            character = "#" * width
+        return character
+
+    def draw(self, width=2, **style):
+        """
+        Draws the grid given the style dictionary and the width of the drawin.
+        :param style: Hash map of the form (int,int) : int or (int,int) : (int,int)
+        :param width: Integer representing the width of the graph
+        :return: None
+        """
+        for y in range(self.height):
+            for x in range(self.width):
+                print("%%-%ds" % width %
+                      self._draw_tile((x, y), style, width), end="")
+            print()
+
+
+class GridWithWeights(SquareGrid):
+
+    def __init__(self, width, height):
+        super().__init__(width, height)
+        self.weights = {}
+
+    def cost(self, from_node, to_node):
+        """
+        Gives the cost of going from from_node to to_node.
+
+        :param from_node: Tuple of two ints
+        :param to_node: Tuple of two ints
+        :returns: int
+        """
+        return self.weights.get(to_node, 1)
+
+

examples/maze_solving_example.py

@@ -1,104 +1,4 @@
 
-class SquareGrid():
-
-    def __init__(self, width, height):
-        self.width = width
-        self.height = height
-        self.walls = set()
-
-    def is_inside(self, point):
-        """ Helper function to know if a given point is inside the Grid.
-
-            :param point: Tuple of two ints
-            :return: Boolean
-        """
-        x, y = point
-        return 0 <= x < self.width and 0 <= y < self.height
-
-    def is_wall(self, point):
-        """ Helper function to know if a given point is a wall.
-
-            :param point: Tuple of two ints
-            :return: Boolean
-        """
-        return point not in self.walls
-
-    def neighbors(self, point):
-        """ Yields the valid neighbours of a given point.
-
-            :param point: Tuple of two ints
-            :return: Generator of tuples of ints
-        """
-
-        x, y = point
-        candidates = [(x + 1, y), (x, y - 1), (x - 1, y), (x, y + 1)]
-        candidates = filter(self.is_inside, candidates)
-        candidates = filter(self.is_wall, candidates)
-        yield from candidates
-
-    def _draw_tile(self, point, style, width):
-        """ Returns a symbol for the current point given the style dictionary and the drawing width.
-
-            :param point: Tuple of two ints
-            :param style: Hash map of the form (int,int) : int or (int,int) : (int,int)
-            :param width: Integer representing the width of the graph
-            :return: string (character)
-        """
-
-        character = "."
-        if 'number' in style and point in style['number']:
-            character = "%d" % style['number'][point]
-        if 'point_to' in style and style['point_to'].get(point, None) is not None:
-            (x1, y1) = point
-            (x2, y2) = style['point_to'][point]
-            if x2 == x1 + 1:
-                character = "\u2192"
-            if x2 == x1 - 1:
-                character = "\u2190"
-            if y2 == y1 + 1:
-                character = "\u2193"
-            if y2 == y1 - 1:
-                character = "\u2191"
-        if 'start' in style and point == style['start']:
-            character = "S"
-        if 'goal' in style and point == style['goal']:
-            character = "E"
-        if 'path' in style and point in style['path']:
-            character = "@"
-        if point in self.walls:
-            character = "#" * width
-        return character
-
-    def draw(self, width=2, **style):
-        """
-        Draws the grid given the style dictionary and the width of the drawin.
-        :param style: Hash map of the form (int,int) : int or (int,int) : (int,int)
-        :param width: Integer representing the width of the graph
-        :return: None
-        """
-        for y in range(self.height):
-            for x in range(self.width):
-                print("%%-%ds" % width %
-                      self._draw_tile((x, y), style, width), end="")
-            print()
-
-
-class GridWithWeights(SquareGrid):
-
-    def __init__(self, width, height):
-        super().__init__(width, height)
-        self.weights = {}
-
-    def cost(self, from_node, to_node):
-        """
-        Gives the cost of going from from_node to to_node.
-
-        :param from_node: Tuple of two ints
-        :param to_node: Tuple of two ints
-        :returns: int
-        """
-        return self.weights.get(to_node, 1)
-
 
 def from_id_width(point, width):
     """
@@ -112,7 +12,8 @@ def from_id_width(point, width):
 
 if __name__ == '__main__':
 
-     import a_star.a_star as a_star
+     import a_star
+     from a_star.tools import GridWithWeights
      import random
 
      # Construct a cool wall collection from this aparently arbitraty points.

tests/__pycache__/test_suite.cpython-35.pyc

@@ -1,6 +1,6 @@
 
 import unittest
-import a_star.a_star as a_star
+import a_star
 
 
 

tests/test_suite.py renamed to tests/test_dijkstra_heap.py

@@ -0,0 +1,52 @@
+
+
+import unittest
+import a_star
+from a_star.tools import GridWithWeights
+
+
+def backtrack( came_from_dict , start, end):
+
+    current = end
+    yield current
+    while current != start:
+        current = came_from_dict[current]
+        yield current
+
+class MazeTests(unittest.TestCase):
+
+    def test_maze_1(self):
+        maze = GridWithWeights(4,4)
+        walls = [(1,1),(2,2)]
+        maze.walls = walls
+        weights = {(1,0):20,(3,0) : 2}
+        maze.weights = weights
+        my_solution = [(3,0),(3,1),(3,2),(3,3),(2,3),(1,3),(1,2),(0,2)]
+        end = (3,0)
+        start = (0,2)
+
+        # Call the A* algorithm and get the frontier
+        frontier = a_star.a_star(graph = maze, start=start, end=end)
+        solution = list(backtrack(frontier.visited,start,end))
+        self.assertTrue( solution == my_solution  )
+
+
+    def test_2(self):
+        maze = GridWithWeights(4,4)
+        walls = []
+        maze.walls = walls
+        weights = {(0,0): 3, (0,1):1, (1,1): 4, (2,1):5,(3,1):1,(0,2): 2, (1,2):3, (2,2):3, (3,2): 2}
+        maze.weights = weights
+
+        start = (0,1)
+        end = (3,1)
+
+        # Call the A* algorithm and get the frontier
+        frontier = a_star.a_star(graph = maze, start=start, end=end)
+        maze.draw(width=3, point_to = frontier.visited, start=start, goal=end)
+        maze.draw(width=3, number = frontier.costs, start=start, goal=end)
+        print(frontier.visited)
+
+
+if __name__ == "__main__":
+    unittest.main()