Ad

A* Pathfinding - Euclidean Distance Heuristic Behaving Worse Than Diagonal Distance

- 1 answer

I implemented the A* pathfinding algorithm according to this: https://www.redblobgames.com/pathfinding/a-star/introduction.html

My grid has a lot of obstacles (more than ten thousand) and is very big. I understand that, in order to get one of the shortest paths, I need to implement an admissible heuristic, so it doesn't over-estimate the distance between the current point and the goal. In theory, euclidean distance must always be less or equal. However, using it, I don't get the shortest path at all, because using diagonal (Chebyshev or octile) distance I get a shorter path. Why is that? Am I missing something? Here is the code:

graph.cost always returns 1

graph.neighbors returns the 8 adiacent positions (less if there are obstacles)

def a_star_search(graph, start, goal):
    frontier = PriorityQueue()
    frontier.put(start, 0)
    came_from = {}
    cost_so_far = {}
    came_from[start] = None
    cost_so_far[start] = 0

    while not frontier.empty():
        current = frontier.get()

        if current == goal:
            break

        for next in graph.neighbors(current):
            new_cost = cost_so_far[current] + graph.cost(current, next)
            if next not in cost_so_far or new_cost < cost_so_far[next]:
                cost_so_far[next] = new_cost
                priority = new_cost + heuristic(goal, next)
                frontier.put(next, priority)
                came_from[next] = current

    return get_path(came_from, start, goal)

def heuristic(a, b):
    dx = abs(b[0] - a[0])
    dy = abs(b[1] - a[1])
    D = 1
    #with D2 = 1 it's even slower but more accurate
    D2 = math.sqrt(2)
    #Diagonal distance - this is more accurate
    #return D*(dx + dy) + (D2 - 2*D)*min(dx, dy)
    #Euclidean distance - this is faster and less accurate
    return math.sqrt(dx*dx + dy*dy)
Ad

Answer

The problem is that because the neighbours are all 8 adjacent grid points, and the cost between all of them is 1, euclidean distance is overestimating the cost between diagonal points.

Real distance between diagonal points: 1

Estimated distance : sqrt(2) = 1.41421356237

So euclidean distance is not admissible for your graph!

Ad
source: stackoverflow.com
Ad