initial commit

volkerp · volkerp · commit 32ca6a75488e · 2018-09-06T23:37:52.000+02:00
diff --git a/README.md b/README.md
@@ -0,0 +1,10 @@
+QuadTree A*
+===========
+
+Python programm showing A* path finding on quadtree representation of a 2D map.
+
+```python
+python3 demo.py
+```
+
+![demo](https://github.com/volkerp/quadtree_Astar/raw/master/screenshot.png "demo.py")
diff --git a/astar.py b/astar.py
@@ -0,0 +1,58 @@
+""" generic implementation of A* path finding algorithm
+
+    (c) Volker Poplawski 2018
+"""
+# priority queue dictionary
+from pqdict import pqdict
+
+
+def astar(adjafunc, distfunc, heurfunc, start, goal):
+    """ adjafunc: node -> List(nodes)
+        distfunc: node, node -> double
+        start: start node
+        goal: end node. Terminate when reached. 
+
+        Return dict node -> absolute dist from start, dict node -> path predessor node
+    """
+    D = {start: 0}                   # final absolute distances
+    P = {}                           # predecessors
+    Q = pqdict({start: 0})           # fringe/frontier maps unexpanded node to estimated dist to goal
+
+    considered = 0           # count how many nodes have been considered on multiple paths
+
+    # keep expanding nodes from the fringe
+    # until goal node is reached
+    # or no more new nodes can be reached and fringe runs empty
+    
+    for n, estimation in Q.popitems():   # pop node with min estimated costs from queue
+        if n == goal:                    # reached goal node
+            break                        # stop expanding nodes
+
+        for neighb in adjafunc(n):      # for all neighbours/adjacent of current node n
+            considered += 1
+            dist = D[n] + distfunc(n, neighb)        # calculate distance to neighbour: cost to current + cost reaching neighbour from current
+            if neighb not in D or D[neighb] > dist:  # if neighbour never visited or shorter using this way
+                D[neighb] = dist                     # found (shorter) distance to neighbour
+                Q[neighb] = dist + heurfunc(neighb, goal)   # estimate distance from neighbour to goal
+                P[neighb] = n                        # remember we reached neighbour via n  
+
+    # expanding done: distance map D populated
+
+    if goal not in D:                # goal node not in distance map
+        return None, D, considered   # no path to goal found
+
+    # build path from start to goal
+    # by walking backwards on the predecessor map
+
+    path = []              # start with empty path
+    n = goal               # at the goal node
+    
+    while n != start:      # while not yet at the start node
+        path.insert(0, n)  #     prepend node to path
+        n = P[n]           #     get predecessor of node
+        
+    path.insert(0, start)  # dont forget the start node
+
+    return path, D, considered
+
+
diff --git a/demo.py b/demo.py
@@ -0,0 +1,233 @@
+""" demonstration of A* routing on a quadtree representation of a 2D map
+
+    (c) Volker Poplawski 2018
+"""
+from tkinter import *
+from PIL import ImageTk, ImageDraw
+import mapgen
+import quadtree
+import astar
+import graph
+
+
+# square map height and width. power of 2. e.g 256, 512, 1024
+MAPSIZE = 512
+
+
+class MainObject:
+    def run(self):
+        self.mapimage = None
+        self.quadtree = None
+        self.startpoint = None
+        self.drag_startp = False
+        
+        self._setupgui()
+        
+        self.root.mainloop()    
+
+
+    def _setupgui(self):
+        self.root = Tk()
+        self.root.title("QuadTree A*")
+
+        self.canvas = Canvas(self.root, bg='gray', width=MAPSIZE, height=MAPSIZE)
+        self.canvas.pack(side=LEFT)
+
+        self.image_item = self.canvas.create_image((0, 0), anchor=NW)
+
+        rightframe = Frame(self.root)
+        rightframe.pack(side=LEFT, fill=Y)
+
+        mapframe = Frame(rightframe, relief=SUNKEN, borderwidth=2)
+        mapframe.pack(padx=5, pady=5)
+        
+        label = Label(mapframe, text="Map", font=("Helvetica", 13))
+        label.pack()
+
+        frame1 = Frame(mapframe)
+        frame1.pack(fill=X, padx=4)
+
+        kernellbl = Label(frame1, text="Kernel Size")
+        kernellbl.pack(side=LEFT, pady=4)
+
+        self.kernelsizevar = StringVar(self.root)
+        self.kernelsizevar.set("7*7")
+        kernelmenu = OptionMenu(frame1, self.kernelsizevar, "13*13", "11*11", "9*9", "7*7", "5*5", "3*3")
+        kernelmenu.pack(fill=X, expand=True)
+
+        frame2 = Frame(mapframe)
+        frame2.pack(fill=X, padx=4)
+        
+        iterslbl = Label(frame2, text="Num Iterations")
+        iterslbl.pack(side=LEFT, pady=4)
+
+        var = StringVar(self.root)
+        var.set("40")
+        self.iterspin = Spinbox(frame2, from_=0, to=100, textvariable=var)
+        self.iterspin.pack(expand=True)
+
+        genbtn = Button(mapframe, text="Generate Map", command=self.onButtonGeneratePress)
+        genbtn.pack(pady=2)
+
+        qtframe = Frame(rightframe, relief=SUNKEN, borderwidth=2)
+        qtframe.pack(fill=X, padx=5, pady=5)
+        
+        label = Label(qtframe, text="QuadTree", font=("Helvetica", 13))
+        label.pack()
+
+        frame1 = Frame(qtframe)
+        frame1.pack(fill=X, padx=4)
+
+        label = Label(frame1, text="Depth Limit")
+        label.pack(side=LEFT, pady=4)
+
+        var = StringVar(self.root)
+        var.set("100")        
+        self.limitspin = Spinbox(frame1, from_=2, to=100, textvariable=var)
+        self.limitspin.pack(expand=True)
+        
+        self.qtlabelvar = StringVar()
+        label = Label(qtframe, fg='#FF8080', textvariable=self.qtlabelvar)
+        label.pack()
+
+        quadtreebtn = Button(qtframe, text="Generate QuadTree", command=self.onButtonQuadTreePress)
+        quadtreebtn.pack(pady=2)
+        
+        astarframe = Frame(rightframe, relief=SUNKEN, borderwidth=2)
+        astarframe.pack(fill=X, padx=5, pady=5)
+                
+        label = Label(astarframe, text="Path", font=("Helvetica", 13))
+        label.pack()
+
+        self.pathlabelvar = StringVar()
+        label = Label(astarframe, fg='#0000FF', textvariable=self.pathlabelvar)
+        label.pack()
+
+        self.astarlabelvar = StringVar()
+        label = Label(astarframe, fg='#8080FF', textvariable=self.astarlabelvar)
+        label.pack()
+
+        label = Label(rightframe, text="Instructions", font=("Helvetica", 13))
+        label.pack()
+        label = Label(rightframe, justify=LEFT, text=
+        "Generate a random map.\n"
+        "Black regions are impassable.\n"
+        "Generate QuadTree on map.\n"
+        "Set start position by dragging blue circle.\n"
+        "Click anywhere on map to find a path.")
+        label.pack(padx=14)
+
+        self.canvas.bind('<ButtonPress-1>', self.onMouseButton1Press)
+        self.canvas.bind('<ButtonRelease-1>', self.onMouseButton1Release)
+        self.canvas.bind('<B1-Motion>', self.onMouseMove)
+
+
+    def onMouseButton1Press(self, event):
+        if not self.quadtree:
+            return
+
+        if self.startpoint in self.canvas.find_overlapping(event.x, event.y, event.x, event.y):
+            self.drag_startp = True
+            return
+        
+        startx, starty, _, _ = self.canvas.coords(self.startpoint)
+        start = self.quadtree.get(startx + 6, starty + 6)
+        goal = self.quadtree.get(event.x, event.y)
+
+        adjacent = graph.make_adjacent_function(self.quadtree)
+        path, distances, considered = astar.astar(adjacent, graph.euclidian, graph.euclidian, start, goal)
+
+        im = self.qtmapimage.copy()
+        draw = ImageDraw.Draw(im)
+
+        self.astarlabelvar.set("Nodes visited: {} considered: {}".format(len(distances), considered))
+        for tile in distances:
+            fill_tile(draw, tile, color=(0xC0, 0xC0, 0xFF))
+
+        if path:
+            self.pathlabelvar.set("Path Cost: {}  Nodes: {}".format(round(distances[goal], 1), len(path)))
+            for tile in path:
+                fill_tile(draw, tile, color=(0, 0, 255))
+        else:
+            self.pathlabelvar.set("No Path found.")
+
+        self._updateimage(im)
+
+    
+    def onMouseButton1Release(self, event):
+        self.drag_startp = False
+        
+    
+    def onMouseMove(self, event):
+        if self.drag_startp:
+            self.canvas.coords(self.startpoint, event.x-6, event.y-6, event.x+6, event.y+6)
+            
+
+    def onButtonGeneratePress(self):
+        ksize = int(self.kernelsizevar.get().split('*')[0])
+        numiter = int(self.iterspin.get())
+
+        self.root.config(cursor="watch")
+        self.root.update()
+        self.mapimage = mapgen.generate_map(MAPSIZE, kernelsize=ksize, numiterations=numiter)
+        self._updateimage(self.mapimage)
+        self.quadtree = None
+        self.qtlabelvar.set("") 
+        self.canvas.delete(self.startpoint)
+        self.startpoint = None
+        self.astarlabelvar.set("")
+        self.pathlabelvar.set("")
+        self.root.config(cursor="")        
+        
+
+    def onButtonQuadTreePress(self):
+        if not self.mapimage:
+            return
+        
+        depthlimit = int(self.limitspin.get())
+        self.quadtree = quadtree.Tile(self.mapimage, limit=depthlimit)
+        self.qtmapimage = self.mapimage.copy()
+        draw = ImageDraw.Draw(self.qtmapimage)
+        draw_quadtree(draw, self.quadtree, 8)
+        self._updateimage(self.qtmapimage)
+        
+        self.qtlabelvar.set("Depth: {}  Nodes: {}".format(self.quadtree.depth(), self.quadtree.count()))
+        self.astarlabelvar.set("")
+        self.pathlabelvar.set("")
+        
+        if not self.startpoint:
+            pos = MAPSIZE//2
+            self.startpoint = self.canvas.create_oval(pos-6, pos-6, pos+6, pos+6, fill='#2028FF', width=2)
+        
+
+    def _updateimage(self, image):
+        self.imagetk = ImageTk.PhotoImage(image)
+        self.canvas.itemconfig(self.image_item, image=self.imagetk)
+
+
+
+
+def draw_quadtree(draw, tile, maxdepth):
+    if tile.level == maxdepth:
+        draw_tile(draw, tile, color=(255, 110, 110))
+        return
+    
+    if tile.childs:
+        for child in tile.childs:
+            draw_quadtree(draw, child, maxdepth)
+    else:
+        draw_tile(draw, tile, color=(255, 110, 110))
+
+    
+def draw_tile(draw, tile, color):
+    draw.rectangle([tile.bb.x, tile.bb.y, tile.bb.x+tile.bb.w, tile.bb.y+tile.bb.h], outline=color)
+
+
+def fill_tile(draw, tile, color):
+    draw.rectangle([tile.bb.x+1, tile.bb.y+1, tile.bb.x+tile.bb.w-1, tile.bb.y+tile.bb.h-1], outline=None, fill=color)
+
+
+
+if __name__ == '__main__':
+    o = MainObject()
+    o.run()
diff --git a/graph.py b/graph.py
@@ -0,0 +1,51 @@
+""" graph representation functions
+
+    (c) Volker Poplawski 2018
+"""
+import quadtree
+import math
+from mapgen import IMPASSABLE, PASSABLE
+
+
+def euclidian(start, end):
+    dx, dy = start.center()[0] - end.center()[0], start.center()[1] - end.center()[1]
+    return math.sqrt(dx**2 + dy**2)
+
+
+def manhatten(start, end):
+    dx, dy = start.center()[0] - end.center()[0], start.center()[1] - end.center()[1]
+    return dx + dy
+
+
+def neighbours(qt, tile):
+    """
+    Return neighbour tiles for tile in quadtree.
+    
+    There are more efficient ways to find neighbouring tiles in a quadtree!
+    Here we simply intersect the whole quadtree with a slightly expanded bounding box
+    of the query tile.
+    """
+    neigh = []
+    qt.intersect(quadtree.BoundingBox(tile.bb.x - 1, tile.bb.y -1, tile.bb.w + 2, tile.bb.h + 2), neigh)
+    return neigh
+
+
+
+def make_adjacent_function(quadtree):
+    """
+    Return function suitable as adjacent function as parameter for call to A*
+    
+    this wrapper function captures the quadtree in a closure of the adjacent function
+    """
+    def adjacent(tile):
+        a = []
+        for neighbour in neighbours(quadtree, tile):
+            assert neighbour.childs is None        # must be leaf node
+            if neighbour.color != IMPASSABLE:
+                a.append(neighbour)
+
+        return a
+
+    return adjacent
+
+
diff --git a/mapgen.py b/mapgen.py
@@ -0,0 +1,29 @@
+""" generate random terrain-like 2D image
+
+    (c) Volker Poplawski 2018
+"""
+from PIL import Image, ImageFilter
+import random
+
+
+IMPASSABLE = 0, 0, 0
+PASSABLE = 220, 220, 220
+
+
+def generate_map(size, kernelsize, numiterations):
+    im = Image.new('RGB', (size, size), color=IMPASSABLE)
+    
+    # init with random data
+    for x in range(0, im.width):
+        for y in range(0, im.height):
+            im.putpixel((x, y), random.choice([IMPASSABLE, PASSABLE]))
+
+    # apply filter multiple times
+    for i in range(numiterations):
+        im = im.filter(ImageFilter.RankFilter(kernelsize, kernelsize**2 // 2))
+
+    return im
+
+
+
+
diff --git a/quadtree.py b/quadtree.py
diff --git a/screenshot.png b/screenshot.png
