org.jgrapht.alg.shortestpath.DijkstraShortestPath Java Examples

/**
 * Get the shortest path connecting given locations (two or more). The path between successive pairs of locations
 * is computed with Dijkstra's algorithm, where edge weights are path lengths.
 * @param locations At least two location names.
 * @return The shortest path connecting given locations.
 */
public PoseSteering[] getShortestPath(String[] locations) {
	if (locations.length < 2) throw new Error("Please provide at least two locations for path extraction!");
	DijkstraShortestPath<String, DefaultWeightedEdge> dijkstraShortestPath = new DijkstraShortestPath<String, DefaultWeightedEdge>(graph);
	ArrayList<PoseSteering> overallShortestPath = new ArrayList<PoseSteering>();
	for (int k = 0; k < locations.length-1; k++) {
	    GraphPath<String, DefaultWeightedEdge> gp = dijkstraShortestPath.getPath(locations[k], locations[k+1]);			
	    if (gp == null) return null;
	    List<String> oneShortestPath = gp.getVertexList();
	    ArrayList<PoseSteering> allPoses = new ArrayList<PoseSteering>();
	    for (int i = 0; i < oneShortestPath.size()-1; i++) {
	    	//PoseSteering[] onePath = loadKnownPath(oneShortestPath.get(i),oneShortestPath.get(i+1));
	    	PoseSteering[] onePath = paths.get(oneShortestPath.get(i)+"->"+oneShortestPath.get(i+1));
	    	if (i == 0) allPoses.add(onePath[0]);
	    	for (int j = 1; j < onePath.length-1; j++) {
	    		allPoses.add(onePath[j]);
	    	}
	    	if (i == oneShortestPath.size()-2) allPoses.add(onePath[onePath.length-1]);
	    }
	    if (k == 0) overallShortestPath.add(allPoses.get(0));
	    for (int i = 1; i < allPoses.size(); i++) {
	    	overallShortestPath.add(allPoses.get(i));
	    }
	}
	return overallShortestPath.toArray(new PoseSteering[overallShortestPath.size()]);
}
 

/**
 * Get the shortest path connecting given locations (two or more). The path between successive pairs of locations
 * is computed with Dijkstra's algorithm, where edge weights are path lengths.
 * @param locations At least two location names.
 * @return The shortest path connecting given locations.
 */
public static PoseSteering[] getShortestPath(String ... locations) {
	if (locations.length < 2) throw new Error("Please provide at least two locations for path extraction!");
	DijkstraShortestPath<String, DefaultWeightedEdge> dijkstraShortestPath = new DijkstraShortestPath<String, DefaultWeightedEdge>(graph);
	ArrayList<PoseSteering> overallShortestPath = new ArrayList<PoseSteering>();
	for (int k = 0; k < locations.length-1; k++) {
	    GraphPath<String, DefaultWeightedEdge> gp = dijkstraShortestPath.getPath(locations[k], locations[k+1]);			
	    if (gp == null) return null;
	    List<String> oneShortestPath = gp.getVertexList();
	    ArrayList<PoseSteering> allPoses = new ArrayList<PoseSteering>();
	    for (int i = 0; i < oneShortestPath.size()-1; i++) {
	    	//PoseSteering[] onePath = loadKnownPath(oneShortestPath.get(i),oneShortestPath.get(i+1));
	    	PoseSteering[] onePath = paths.get(oneShortestPath.get(i)+"->"+oneShortestPath.get(i+1));
	    	if (i == 0) allPoses.add(onePath[0]);
	    	for (int j = 1; j < onePath.length-1; j++) {
	    		allPoses.add(onePath[j]);
	    	}
	    	if (i == oneShortestPath.size()-2) allPoses.add(onePath[onePath.length-1]);
	    }
	    if (k == 0) overallShortestPath.add(allPoses.get(0));
	    for (int i = 1; i < allPoses.size(); i++) {
	    	overallShortestPath.add(allPoses.get(i));
	    }
	}
	return overallShortestPath.toArray(new PoseSteering[overallShortestPath.size()]);
}
 

@Override
public IExpr evaluate(final IAST ast, EvalEngine engine) {
	try {
		GraphExpr<ExprEdge> gex = createGraph(ast.arg1());
		if (gex == null) {
			return F.NIL;
		}

		Graph<IExpr, ExprEdge> g = gex.toData();

		DijkstraShortestPath<IExpr, ExprEdge> dijkstraAlg = new DijkstraShortestPath<>(g);
		SingleSourcePaths<IExpr, ExprEdge> iPaths = dijkstraAlg.getPaths(ast.arg2());
		GraphPath<IExpr, ExprEdge> path = iPaths.getPath(ast.arg3());

		return Object2Expr.convertList(path.getVertexList());
	} catch (RuntimeException rex) {
		if (FEConfig.SHOW_STACKTRACE) {
			rex.printStackTrace();
		}
	}
	return F.NIL;
}
 

private static GraphPath<EntityReference, DefaultEdge> findShortestPath(Graph<EntityReference, DefaultEdge> g, EntityReference start, EntityReference end) {
    DijkstraShortestPath<EntityReference, DefaultEdge> dijkstraAlg =
            new DijkstraShortestPath<>(g);

    SingleSourcePaths<EntityReference, DefaultEdge> iPaths = dijkstraAlg.getPaths(start);
    return iPaths.getPath(end);
}
 

@Override
protected ShortestPathAlgorithm<String, ModelEdge> createShortestPathAlgorithm(
    Graph<String, ModelEdge> graph) {
  return new DijkstraShortestPath<>(graph);
}
 

@Fuzz
public void dijkstra(@GraphModel(nodes=10, weighted=true) Graph graph) {
    new DijkstraShortestPath<>(graph).getPaths(1);
}
 

@Test
public void givenDirectedGraph_whenGetDijkstraShortestPath_thenGetNotNullPath() {
    DijkstraShortestPath dijkstraShortestPath = new DijkstraShortestPath(directedGraph);
    List<String> shortestPath = dijkstraShortestPath.getPath("v1", "v4").getVertexList();
    assertNotNull(shortestPath);
}