Instantly share code, notes, and snippets.

What would you like to do?
The C++ header file "astar.h" implements the A* graph search (route finding) algorithm using a C++ function template. The interface is written in an STL like style.
// -------------------------------------------------------------------------
// Filename: astar.h
// Version: 1.24
// Date: 2002/03/08
// Purpose: Provide template for a* algorythm
// (c) T.Frogley 1999-2002
// -------------------------------------------------------------------------
#ifndef ASTAR_H
#define ASTAR_H
#ifdef _MSC_VER
//identifier was truncated to '255' characters in the browser information
#pragma warning (disable : 4786)
//include standard library code
#include <vector>
#include <deque>
#include <functional>
#include <algorithm>
#include <limits>
#include <time.h>
#include <iostream>
namespace astar
//from <vector>
using std::vector;
//from <deque>
using std::deque;
//from <functional>
using std::binary_function;
using std::greater;
//from <algorithm>
using std::pop_heap;
using std::push_heap;
//max should be in <algorithm>
//unfortunatly the Microsoft compiler\headers arn't standard compliant
#ifdef _MSC_VER
#ifdef max
#undef max
template<class T> inline
const T& max(const T& a, const T& b)
{ return (a>b)?a:b; }
using std::max;
//node = class encapsulating a location on the graph
/* example node class for use with astar,
minimal interface -
note it is recomended that in most cases nodes are implemented as pointers to data,
struct example_node{
//default, & copy constructor, &
//assignment operator should be available
//for fetching connected nodes, and costs
struct iterator{
//copy constructor and assignment operator should be available
typedef double cost_type; //typedef required, must be scalar type
example_node value()const; //node
cost_type cost()const; //cost/distance to node
iterator& operator++(); //next node
bool operator!=(iterator v);//used by search
//Get first, and past-end iterators
iterator begin()const;
iterator end()const;
//equality operator, required
//note: fuzzy equality may be useful
bool operator==(const xynode b);
//heuristic = binary functor, estimates of cost from node A to node B
//use this heuristic when costs don't apply
template<class T>
struct no_heuristic{
typename T::iterator::cost_type operator()(const T a, const T b)
{ return 1; }
//some useful template functions for creating heuristics for movement on a 2d plane
//The standard heuristic is the Manhattan distance.
//Look at your cost function and see what the least cost is
//for moving from one space to another.
//The heuristic should be cost times manhattan distance:
template<class T> inline
const T manhattan_distance(const T& x1, const T& y1, const T& x2, const T& y2)
return (abs(x1-x2)+abs(y1-y2));
//If on your map you allow diagonal movement, then you need a different heuristic.
//The Manhattan distance for (4 east, 4 north) will be 8.
//However, you could simply move (4 northeast) instead, so the heuristic should be 4.
//This function handles diagonals:
template<class T> inline
const T diagonal_distance(const T& x1, const T& y1, const T& x2, const T& y2)
return (max(abs(x1-x2),abs(y1-y2)));
//If your units can move at any angle (instead of grid directions),
//then you should probably use a straight line distance:
template<class T> inline
const T straight_distance(const T& x1, const T& y1, const T& x2, const T& y2)
T dx = (x1-x2);
T dy = (y1-y2);
return ( sqrt(dx*dx + dy*dy) );
//One thing that can lead to poor performance is ties in the heuristic.
//When several paths have the same f value, they are all explored, even
//though we only need to explore one of them. To solve this problem, we
//can add a small tie-breaker to the heuristic.
//This tie breaker also can give us nicer looking paths:
//x1,y1 = start position
//x2,y2 = current position
//x3,y3 = target position
template<class T> inline
const T amits_modifier(const T& x1, const T& y1, const T& x2, const T& y2, const T& x3, const T& y3)
T dx1 = x2 - x3;
T dy1 = y2 - y3;
T dx2 = x1 - x3;
T dy2 = y1 - y3;
T cross = dx1*dy2 - dx2*dy1;
if( cross<0 ) cross = -cross;
return cross;
//node_link (astar implementation helper class)
//wraps up a node with movement cost / heuristic info
//and an index to its parent node in the nodes list
template<class T>
struct node_link{
typedef typename T::iterator::cost_type scalar;
node_link(T n, scalar g, scalar h, int p=-1):
{ }
inline bool operator>(const node_link<T> &b)const
{ return (myG+myH > b.myG+b.myH); }
T myNode;
scalar myG, myH;
int myParent;
//binary_lookup functor (astar implemetatoin helper class)
// bfn : binary functor to pass value to
// key : key to container
// con : random access container, must support [ key ]
//??? Why doesn't this work with c-style arrays ???
template<class bfn, class key, class con>
class binary_lookup : public binary_function<key, key, typename bfn::result_type> {
//constructor, take a copy of functor,
//and keep a reference to the container
binary_lookup(const bfn& f, con& _c):
{ }
//look up two values in contianer from keys a and b,
//pass values to binary functor, and return result
result_type operator()(
const key& a,
const key& b )
{ return fn(c[a], c[b]); }
bfn fn;
con& c;
//configuration info for astar algorythm
//also used to return some additional information about the finished search
template<class nodeType>
struct config{
typedef typename nodeType::iterator::cost_type scalar;
//construct with sensable defaults / empty results
node_limit(std::numeric_limits<unsigned int>::max()),
{ }
//configuration variables
//set this to restrict the number of nodes astar will open
//has the effect of limiting the amount of time spent searching
unsigned int node_limit;
//cost limit
//set this to restrict the maximum distance considered
//acceptable for a route
//if astar cannot find a shorter route than this it will fail
scalar cost_limit;
//result variables
//astart sets the to the total number of nodes it
//'looked at' when the search terminated
unsigned int result_nodes_examined;
//astar sets this to the number of nodes still waiting
//to be examined when the search terminated
unsigned int result_nodes_pending;
//astar sets this to the total number of nodes it fetched
//should equal pending + examined
unsigned int result_nodes_opened;
//astar sets this to equal the total number of nodes
//used to construct the returned route
unsigned int route_length;
//astart sets the to equal the total "cost" of
//the returned route
scalar route_cost;
//astar algorithm, as template,
//find a path from a to b,
//using the given heuristic,
//places results in container [ any class that can push_front( nodeType ) ]
//returns flase if no route exists
//returns true if a complete route is found
//returns true if it exceeds node_limit, but a partial route is found
//returns false (aborts with a partial route) if it exceeds cost_limit
template<class heuristicFunctor, class nodeType, class container>
bool astar(const nodeType a, const nodeType b, container &results, heuristicFunctor heuristic, config<nodeType> &cfg)
clock_t time = clock();
typedef node_link<nodeType> node;
typedef vector<int> index_container;
typedef deque<node> node_container;
typedef typename nodeType::iterator node_iterator;
typedef typename nodeType::iterator::cost_type scalar;
node_container nodes; //all nodes opened
index_container pending; //sorted index to pending nodes
index_container done; //unsorted index to nodes already explored
index_container::iterator j;
index_container::const_iterator k;
int index;
bool complete = false;
//reserve space in index vectors to avoid reallocation
if (cfg.node_limit != std::numeric_limits<unsigned int>::max()){
pending.reserve( cfg.node_limit / 2 );
done.reserve( cfg.node_limit / 2 );
//create the indirect comparison object
greater<node> aFunctor;
> sort_index_object(aFunctor, nodes);
//tempory storage for 'working' node data
node current;
nodeType next;
//stick the fist node into the list,
//and its index into the pending list
nodes.push_back(node( a, 0, heuristic(a,b), -1 ));
//get top rated node
index = pending.front();
current = nodes[index];
//remove it from pending list
pop_heap( pending.begin(), pending.end(), sort_index_object );
//stick it in the list of examined nodes
//found target?
complete = current.myNode==b;
if (complete) break;
//failed (based on distance)
if (current.myG+current.myH>cfg.cost_limit) break;
//for each node connected to the current one
node_iterator i(current.myNode.begin());
const node_iterator end(current.myNode.end());
for (;i!=end;++i){
next = i.value();
//!!! the client code might have a faster
//!!! way of checking if the node had already been visited
//search pending list for "the same" node
if (nodes[*j].myNode==next){
//not in the pending list
if (j==k){
//search list of already explored nodes for "the same" node
if (nodes[*j].myNode==next){
//not in done list (or pending list)
if (j==k){
//add to pending list
nodes.push_back( node(next, i.cost()+current.myG, heuristic(next, b), index ) );
pending.push_back( nodes.size()-1 );
push_heap( pending.begin(), pending.end(), sort_index_object );
//its in the pending list, but is this a better version ?
if (i.cost()+current.myG<nodes[*j].myG){
//replace node with this one
nodes[*j] = node(next, i.cost()+current.myG, nodes[*j].myH, index );
// This is allowed but it's not obvious why:
// see:
push_heap( pending.begin(), j+1, sort_index_object );
}while (!pending.empty() && nodes.size()<cfg.node_limit);
clock_t elapsed1 = clock() - time;
cfg.route_length = 0;
//did not exit because a route was found
if (!complete){
//ran out of time
if (nodes.size()>=cfg.node_limit && !pending.empty()){
//best potential
current = nodes[pending.front()];
//search list of already explored nodes for "better" compromise
if (current.myH>nodes[*j].myH){
current = nodes[*j];
//partial routes should not be considered a failure
complete = true;
elapsed1 = clock() - time;
//store route length
//(including estimate of remaining distance for partial routes)
cfg.route_cost = current.myG+current.myH;
//store results of search in "container"
current = nodes[current.myParent];
//store stats for calling code
cfg.result_nodes_opened = nodes.size();
cfg.result_nodes_pending = pending.size();
cfg.result_nodes_examined = done.size();
//report stats
clock_t elapsed2 = clock()-time;
std::cout << "astar stats\n";
std::cout << "ticks:\t\t" << elapsed2 << " (" << elapsed1 << ", " << elapsed2-elapsed1 << ")\n";
std::cout << "(seconds):\t" << (float)elapsed2/CLOCKS_PER_SEC << "\n";
std::cout << "route length:\t" << cfg.route_length << " nodes (" << cfg.route_cost << " units)\n";
std::cout << "nodes examined:\t" << cfg.result_nodes_examined << "\n";
std::cout << "nodes pending:\t" << cfg.result_nodes_pending << "\n";
std::cout << "(total):\t" << cfg.result_nodes_opened << "\n";
return complete;
}//void astar(...);
}//namespace astar

This comment has been minimized.

Copy link

zk4 commented May 28, 2014

A little complicated ,but, great job!

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment