Class AStar
- All Implemented Interfaces:
Algorithm
public class AStar extends Object implements Algorithm
A* computes the shortest path from a node to another in a graph. It guarantees that the path found is the shortest one, given its heuristic is admissible, and a path exists between the two nodes. It will 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 always returns 0. This makes A* an * equivalent of
the Dijkstra algorithm, but also makes it less efficient.
If there are several equivalent shortest paths between the two nodes, the returned one is arbitrary. Therefore this AStar algorithm works with multi-graphs but if two edges between two nodes have the same properties, the one that will be chosen will be arbitrary.
Usage
The basic usage is to create an instance of A* (optionally specify a AStar.Costs
object), 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 (and should) create your own cost functions implementing the
AStar.Costs
interface.
You can also test the default euclidean "distance" cost function on a graph that has
"x" and "y" values. You specify the AStar.Costs
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()); } }
- Computational Complexity :
- The complexity of A* depends on the heuristic.
-
Nested Class Summary
Nested Classes Modifier and Type Class Description static interface
AStar.Costs
the distance between the current position and the target.static class
AStar.DefaultCosts
An implementation of the Costs interface that provides a default heuristic.static class
AStar.DistanceCosts
An implementation of the Costs interface that assume that the weight of edges is an Euclidean distance in 2D or 3D. -
Constructor Summary
-
Method Summary
Modifier and Type Method Description 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)
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 calledcompute()
orcompute(String, String)
, if thegetShortestPath()
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.
-
Constructor Details
-
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
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 Details
-
setSource
Change the source node. This clears the already computed path, but preserves the target node name.- Parameters:
nodeName
- Identifier of the source node.
-
setTarget
Change the target node. This clears the already computed path, but preserves the source node name.- Parameters:
nodeName
- Identifier of the target node.
-
setCosts
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 theAlgorithm.compute()
method to initialize or reset the algorithm according to the new given graph. -
compute
public void compute()Description copied from interface:Algorithm
Run the algorithm. TheAlgorithm.init(Graph)
method has to be called before computing.- Specified by:
compute
in interfaceAlgorithm
- 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 calledcompute()
orcompute(String, String)
, if thegetShortestPath()
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 has several connected components. It also return true if the algorithm did not run.- Returns:
- True if there is no possible path from the source to the destination or if the algorithm did not run.
-
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
- Parameters:
source
- Identifier of the source node.target
- Identifier of the target node.
-