When an edge cost is updated, as we have to when we discover obstacles in the before mentioned robotics competition, the algorithm only propagates the new changes through the table in such a way that only related paths (paths that contain the updated edge) are changed, generating new paths with as little work as possible (hence the power of D*).

I also use A* for the bot combat decisions. There we have a dynamic situation where D* would be good. But I don’t know if it would be a performance gain since the decisions aren’t so long.

A* vs. D* topic: I poorly defined why I like D* over A*. The reason is simply because of my project’s needs: In my robotics application, the search space is not only HUGE (hundreds of square meters the robot has to drive around) but the arena is unknown at run-time. The robot fills in its “known world” over time, as it discovers obstacles, while driving to a goal.

During each “known world” update (we queued up sensor readings into burst-writes for performance), we actually only update the node/edge values within our D* map. For added performance (this code was never deployed) we removed nodes that were surrounded by obstacles as well as only added new nodes if the robot *really* thinks there is an obstacle. From there, the algorithm doesn’t need to run through all possible paths like A* does (hence the dynamic programming aspect!), but only updates the paths associated with the node/edges that have been changed.

This is a very subtle difference, and frankly the performance gain from our own D* implementation wasn’t huge, but when we ran simulations of worlds that had overly complex obstacles (fences, clustered poles, etc..), D* outperformed by far! Simply: A* is great for well-defined static worlds, D* is great for dynamic changing worlds. That’s it! I think A* seems to best fit your needs since maps are very well defined; any needed path planning data could just be pre-calculated.

Oh, and maybe I’m dumb, but aren’t the heuristic function for A* and D* still equivalent (constant)? If you want a total mind-fuck in terms of powerful path planners, look into V* from Penn State (http://bit.ly/9pXsTi) which uses language theory and has a theoretical lower constant than A* and D*, assuming you live in the future with dozen-core processors! I programmed a proof-of-concept, but couldn’t understand 90% of the paper.

tl;dr – I like path planning.

nint22: D* seemed complicated, I’ll have a look a second time.
“reverse dijkstra algorithm” – isn’t that just A* with a constant heuristic? Why would it be faster?
I would like to talk some day if you want?

On a serious technical note: A* is not a bad approach to your path planning needs, but it’s far from a “fast” approach. Look into D*, or simply “reverse dijkstra algorithm”. It’s a dynamic programming approach to the shortest/cheapest path problem – it performs in O(n^2), which a lower constant than A*’s run-time.

Just wanting to help :^) I do path planning day and night for robotics.