org.graphstream.algorithm
Class AStar

java.lang.Object
  org.graphstream.algorithm.AStar

All Implemented Interfaces:

Algorithm

public class AStar
extends Object
implements Algorithm

An implementation of the A* algorithm.

A* computes the shortest path from a node to another in a graph. It can eventually fail if the two nodes are in two distinct connected components.

In this A* implementation, the various costs (often called g, h and f) are given by a AStar.Costs class. This class must provide a way to compute :

• The cost of moving from a node to another, often called g ;
• The estimated cost from a node to the destination, the heuristic, often noted h ;
• f is the sum of g and h and is computed automatically.

By default the AStar.Costs implementation used uses a heuristic that returns 0 for any heuristic. This makes A* an equivalent of the Dijkstra algorithm, but also makes it far less efficient.

Usage

The basic usage is to create an instance of A*, then to ask it to compute from a shortest path from one target to one destination, and finally to ask for that path:

 AStart astar = new AStar(graph); 
 astar.compute("A", "Z"); // with A and Z node identifiers in the graph. 
 Path path = astar.getShortestPath();
 

The advantage of A* is that it can consider any cost function to drive the search. You can create your own cost functions implementing the AStar.Costs interface.

You can also test the default "distance" cost function on a graph that has "x" and "y" values. You specify the Cost function before calling the compute(String,String) method:

 AStart astar = new AStar(graph); 
 astar.setCosts(new DistanceCosts());
 astar.compute("A", "Z"); 
 Path path = astar.getShortestPath();
 

Example

import java.io.IOException; import java.io.StringReader; import org.graphstream.algorithm.AStar; import org.graphstream.algorithm.AStar.DistanceCosts; import org.graphstream.graph.Graph; import org.graphstream.graph.implementations.DefaultGraph; import org.graphstream.stream.file.FileSourceDGS; public class AStarTest { // B-(1)-C // / \ // (1) (10) // / \ // A F // \ / // (1) (1) // \ / // D-(1)-E static String my_graph = "DGS004\n" + "my 0 0\n" + "an A xy: 0,1\n" + "an B xy: 1,2\n" + "an C xy: 2,2\n" + "an D xy: 1,0\n" + "an E xy: 2,0\n" + "an F xy: 3,1\n" + "ae AB A B weight:1 \n" + "ae AD A D weight:1 \n" + "ae BC B C weight:1 \n" + "ae CF C F weight:10 \n" + "ae DE D E weight:1 \n" + "ae EF E F weight:1 \n" ; public static void main(String[] args) throws IOException { Graph graph = new DefaultGraph("A* Test"); StringReader reader = new StringReader(my_graph); FileSourceDGS source = new FileSourceDGS(); source.addSink(graph); source.readAll(reader); AStar astar = new AStar(graph); //astar.setCosts(new DistanceCosts()); astar.compute("C", "F"); System.out.println(astar.getShortestPath()); } }

Author:

Antoine Dutot, Yoann Pigné

Computational Complexity :

The complexity of A* depends on the heuristic.

Nested Class Summary

static interface	AStar.Costs The definition of an heuristic.
static class	AStar.DefaultCosts An implementation of the Costs interface that provide a default heuristic.
static class	AStar.DistanceCosts An implementation of the Costs interface that assume that the weight of edges is an Euclidian distance in 2D or 3D.

Constructor Summary

AStar()
New A* algorithm.

AStar(org.graphstream.graph.Graph graph)
New A* algorithm on a given graph.

AStar(org.graphstream.graph.Graph graph, String src, String trg)
New A* algorithm on the given graph.

Method Summary

org.graphstream.graph.Path	buildPath(org.graphstream.algorithm.AStar.AStarNode target) Build the shortest path from the target/destination node, following the parent links.
void	compute() Run the algorithm.
void	compute(String source, String target) Call compute() after having called setSource(String) and setTarget(String).
org.graphstream.graph.Path	getShortestPath() The computed path, or null if nor result was found.
void	init(org.graphstream.graph.Graph graph) Initialization of the algorithm.
boolean	noPathFound() After having called compute() or compute(String, String), if the getShortestPath() returns null, or this method return true, there is no path from the given source node to the given target node.
void	setCosts(AStar.Costs costs) Specify how various costs are computed.
void	setSource(String nodeName) Change the source node.
void	setTarget(String nodeName) Change the target node.

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

AStar

public AStar()

New A* algorithm.

AStar

public AStar(org.graphstream.graph.Graph graph)

New A* algorithm on a given graph.

Parameters:

graph - The graph where the algorithm will compute paths.

AStar

public AStar(org.graphstream.graph.Graph graph,
             String src,
             String trg)

New A* algorithm on the given graph.

Parameters:

graph - The graph where the algorithm will compute paths.

src - The start node.

trg - The destination node.

Method Detail

setSource

public void setSource(String nodeName)

Change the source node. This clears the already computed path, but preserves the target node name.

Parameters:

nodeName - Identifier of the source node.

setTarget

public void setTarget(String nodeName)

Change the target node. This clears the already computed path, but preserves the source node name.

Parameters:

nodeName - Identifier of the target node.

setCosts

public void setCosts(AStar.Costs costs)

Specify how various costs are computed. The costs object is in charge of computing the cost of displacement from one node to another (and therefore allows to compute the cost from the source node to any node). It also allows to compute the heuristic to use for evaluating the cost from the current position to the target node. Calling this DOES NOT clear the currently computed paths.

Parameters:

costs - The cost method to use.

init

public void init(org.graphstream.graph.Graph graph)

Description copied from interface: Algorithm

Initialization of the algorithm. This method has to be called before the Algorithm.compute() method to initialize or reset the algorithm according to the new given graph.

Specified by:

init in interface Algorithm

Parameters:

graph - The graph this algorithm is using.

compute

public void compute()

Description copied from interface: Algorithm

Run the algorithm. The Algorithm.init(Graph) method has to be called before computing.

Specified by:

compute in interface Algorithm

See Also:

Algorithm.init(Graph)

getShortestPath

public org.graphstream.graph.Path getShortestPath()

The computed path, or null if nor result was found.

Returns:

The computed path, or null if no path was found.

noPathFound

public boolean noPathFound()

After having called compute() or compute(String, String), if the getShortestPath() returns null, or this method return true, there is no path from the given source node to the given target node. In other words, the graph as several connected components.

Returns:

True if there is no possible path from the source to the destination.

buildPath

public org.graphstream.graph.Path buildPath(org.graphstream.algorithm.AStar.AStarNode target)

Build the shortest path from the target/destination node, following the parent links.

Parameters:

target - The destination node.

Returns:

The path.

compute

public void compute(String source,
                    String target)

Call compute() after having called setSource(String) and setTarget(String).

Parameters:

source - Identifier of the source node.

target - Identifier of the target node.