mxgraph/analysis/mxTraversal.java

/**
 * Copyright (c) 2011-2012, JGraph Ltd
 */
package com.mxgraph.analysis;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import com.mxgraph.costfunction.mxCostFunction;
import com.mxgraph.view.mxCellState;
import com.mxgraph.view.mxGraph;
import com.mxgraph.view.mxGraph.mxICellVisitor;
import com.mxgraph.view.mxGraphView;

/**
 * Implements a collection of utility methods for traversing the
 * graph structure. This does not include tree traversal methods.
 */
public class mxTraversal
{

	/**
	 * Implements a recursive depth first search starting from the specified
	 * cell. Process on the cell is performing by the visitor class passed in.
	 * The visitor has access to the current cell and the edge traversed to
	 * find this cell. Every cell is processed once only.
	 * <pre>
	 * mxTraversal.bfs(analysisGraph, startVertex, new mxICellVisitor()
	 * {
	 * 	public boolean visit(Object vertex, Object edge)
	 * 	{
	 * 		// perform your processing on each cell here
	 *		return false;
	 *	}
	 * });
	 * </pre>
	 * @param aGraph the graph
	 * @param startVertex
	 * @param visitor
	 */
	public static void dfs(mxAnalysisGraph aGraph, Object startVertex, mxICellVisitor visitor)
	{
		dfsRec(aGraph, startVertex, null, new HashSet<Object>(), visitor);
	}

	/**
	 * Core recursive DFS - for internal use
	 * @param aGraph
	 * @param cell
	 * @param edge
	 * @param seen
	 * @param visitor
	 */
	private static void dfsRec(mxAnalysisGraph aGraph, Object cell, Object edge, Set<Object> seen, mxICellVisitor visitor)
	{
		if (cell != null)
		{
			if (!seen.contains(cell))
			{
				visitor.visit(cell, edge);
				seen.add(cell);

				final Object[] edges = aGraph.getEdges(cell, null, false, true);
				final Object[] opposites = aGraph.getOpposites(edges, cell);

				for (int i = 0; i < opposites.length; i++)
				{
					dfsRec(aGraph, opposites[i], edges[i], seen, visitor);
				}
			}
		}
	}

	/**
	 * Implements a recursive breadth first search starting from the specified
	 * cell. Process on the cell is performing by the visitor class passed in.
	 * The visitor has access to the current cell and the edge traversed to
	 * find this cell. Every cell is processed once only.
	 * <pre>
	 * mxTraversal.bfs(analysisGraph, startVertex, new mxICellVisitor()
	 * {
	 * 	public boolean visit(Object vertex, Object edge)
	 * 	{
	 * 		// perform your processing on each cell here
	 *		return false;
	 *	}
	 * });
	 * </pre>
	 * @param aGraph the graph
	 * @param startVertex
	 * @param visitor
	 */
	public static void bfs(mxAnalysisGraph aGraph, Object startVertex, mxICellVisitor visitor)
	{
		if (aGraph != null && startVertex != null && visitor != null)
		{
			Set<Object> queued = new HashSet<Object>();
			LinkedList<Object[]> queue = new LinkedList<Object[]>();
			Object[] q = { startVertex, null };
			queue.addLast(q);
			queued.add(startVertex);

			bfsRec(aGraph, queued, queue, visitor);
		}
	};

	/**
	 * Core recursive BFS - for internal use
	 * @param aGraph
	 * @param queued
	 * @param queue
	 * @param visitor
	 */
	private static void bfsRec(mxAnalysisGraph aGraph, Set<Object> queued, LinkedList<Object[]> queue, mxICellVisitor visitor)
	{
		if (queue.size() > 0)
		{
			Object[] q = queue.removeFirst();
			Object cell = q[0];
			Object incomingEdge = q[1];

			visitor.visit(cell, incomingEdge);

			final Object[] edges = aGraph.getEdges(cell, null, false, false);

			for (int i = 0; i < edges.length; i++)
			{
				Object[] currEdge = { edges[i] };
				Object opposite = aGraph.getOpposites(currEdge, cell)[0];

				if (!queued.contains(opposite))
				{
					Object[] current = { opposite, edges[i] };
					queue.addLast(current);
					queued.add(opposite);
				}
			}

			bfsRec(aGraph, queued, queue, visitor);
		}
	};

	/**
	 * Implements the Dijkstra's shortest path from startVertex to endVertex.
	 * Process on the cell is performing by the visitor class passed in.
	 * The visitor has access to the current cell and the edge traversed to
	 * find this cell. Every cell is processed once only.
	 * <pre>
	 * mxTraversal.dijkstra(analysisGraph, startVertex, endVertex, new mxICellVisitor()
	 * {
	 * 	public boolean visit(Object vertex, Object edge)
	 * 	{
	 * 		// perform your processing on each cell here
	 *		return false;
	 *	}
	 * });
	 * </pre>
	 *
	 * @param aGraph
	 * @param startVertex
	 * @param endVertex
	 * @param visitor
	 * @throws StructuralException - The current Dijkstra algorithm only works for connected graphs
	 */
	public static void dijkstra(mxAnalysisGraph aGraph, Object startVertex, Object endVertex, mxICellVisitor visitor)
			throws StructuralException
	{
		if (!mxGraphStructure.isConnected(aGraph))
		{
			throw new StructuralException("The current Dijkstra algorithm only works for connected graphs and this graph isn't connected");
		}

		Object parent = aGraph.getGraph().getDefaultParent();
		Object[] vertexes = aGraph.getChildVertices(parent);
		int vertexCount = vertexes.length;
		double[] distances = new double[vertexCount];
		//		parents[][0] is the traveled vertex
		//		parents[][1] is the traveled outgoing edge
		Object[][] parents = new Object[vertexCount][2];
		ArrayList<Object> vertexList = new ArrayList<Object>();
		ArrayList<Object> vertexListStatic = new ArrayList<Object>();

		for (int i = 0; i < vertexCount; i++)
		{
			distances[i] = Integer.MAX_VALUE;
			vertexList.add((Object) vertexes[i]);
			vertexListStatic.add((Object) vertexes[i]);
		}

		distances[vertexListStatic.indexOf(startVertex)] = 0;
		mxCostFunction costFunction = aGraph.getGenerator().getCostFunction();
		mxGraphView view = aGraph.getGraph().getView();

		while (vertexList.size() > 0)
		{
			//find closest vertex
			double minDistance;
			Object currVertex;
			Object closestVertex;
			currVertex = vertexList.get(0);
			int currIndex = vertexListStatic.indexOf(currVertex);
			double currDistance = distances[currIndex];
			minDistance = currDistance;
			closestVertex = currVertex;

			if (vertexList.size() > 1)
			{
				for (int i = 1; i < vertexList.size(); i++)
				{
					currVertex = vertexList.get(i);
					currIndex = vertexListStatic.indexOf(currVertex);
					currDistance = distances[currIndex];

					if (currDistance < minDistance)
					{
						minDistance = currDistance;
						closestVertex = currVertex;
					}
				}
			}

			// we found the closest vertex
			vertexList.remove(closestVertex);

			Object currEdge = new Object();
			Object[] neighborVertices = aGraph.getOpposites(aGraph.getEdges(closestVertex, null, true, true, false, true), closestVertex,
					true, true);

			for (int j = 0; j < neighborVertices.length; j++)
			{
				Object currNeighbor = neighborVertices[j];

				if (vertexList.contains(currNeighbor))
				{
					//find edge that connects to the current vertex
					Object[] neighborEdges = aGraph.getEdges(currNeighbor, null, true, true, false, true);
					Object connectingEdge = null;

					for (int k = 0; k < neighborEdges.length; k++)
					{
						currEdge = neighborEdges[k];

						if (aGraph.getTerminal(currEdge, true).equals(closestVertex)
								|| aGraph.getTerminal(currEdge, false).equals(closestVertex))
						{
							connectingEdge = currEdge;
						}
					}

					// check for new distance
					int neighborIndex = vertexListStatic.indexOf(currNeighbor);
					double oldDistance = distances[neighborIndex];
					double currEdgeWeight;

					currEdgeWeight = costFunction.getCost(new mxCellState(view, connectingEdge, null));

					double newDistance = minDistance + currEdgeWeight;

					//final part - updating the structure
					if (newDistance < oldDistance)
					{
						distances[neighborIndex] = newDistance;
						parents[neighborIndex][0] = closestVertex;
						parents[neighborIndex][1] = connectingEdge;
					}
				}
			}
		}

		ArrayList<Object[]> resultList = new ArrayList<Object[]>();
		Object currVertex = endVertex;

		while (currVertex != startVertex)
		{
			int currIndex = vertexListStatic.indexOf(currVertex);
			currVertex = parents[currIndex][0];
			resultList.add(0, parents[currIndex]);
		}

		resultList.add(resultList.size(), new Object[] { endVertex, null });

		for (int i = 0; i < resultList.size(); i++)
		{
			visitor.visit(resultList.get(i)[0], resultList.get(i)[1]);
		}
	};

	/**
	 * Implements the Bellman-Ford shortest path from startVertex to all vertices.
	 *
	 * @param aGraph
	 * @param startVertex
	 * @return a List where List(0) is the distance map and List(1) is the parent map. See the example in GraphConfigDialog.java
	 * @throws StructuralException - The Bellman-Ford algorithm only works for graphs without negative cycles
	 */
	public static List<Map<Object, Object>> bellmanFord(mxAnalysisGraph aGraph, Object startVertex) throws StructuralException
	{
		mxGraph graph = aGraph.getGraph();
		Object[] vertices = aGraph.getChildVertices(graph.getDefaultParent());
		Object[] edges = aGraph.getChildEdges(graph.getDefaultParent());
		int vertexNum = vertices.length;
		int edgeNum = edges.length;
		Map<Object, Object> distanceMap = new HashMap<Object, Object>();
		Map<Object, Object> parentMap = new HashMap<Object, Object>();
		mxCostFunction costFunction = aGraph.getGenerator().getCostFunction();
		mxGraphView view = graph.getView();

		for (int i = 0; i < vertexNum; i++)
		{
			Object currVertex = vertices[i];
			distanceMap.put(currVertex, Double.MAX_VALUE);
		}

		distanceMap.put(startVertex, 0.0);
		parentMap.put(startVertex, startVertex);

		for (int i = 0; i < vertexNum; i++)
		{
			for (int j = 0; j < edgeNum; j++)
			{
				Object currEdge = edges[j];
				Object source = aGraph.getTerminal(currEdge, true);
				Object target = aGraph.getTerminal(currEdge, false);

				double dist = (Double) distanceMap.get(source) + costFunction.getCost(new mxCellState(view, currEdge, null));

				if (dist < (Double) distanceMap.get(target))
				{
					distanceMap.put(target, dist);
					parentMap.put(target, source);
				}

				//for undirected graphs, check the reverse direction too
				if (!mxGraphProperties.isDirected(aGraph.getProperties(), mxGraphProperties.DEFAULT_DIRECTED))
				{
					dist = (Double) distanceMap.get(target) + costFunction.getCost(new mxCellState(view, currEdge, null));

					if (dist < (Double) distanceMap.get(source))
					{
						distanceMap.put(source, dist);
						parentMap.put(source, target);
					}
				}

			}
		}

		for (int i = 0; i < edgeNum; i++)
		{
			Object currEdge = edges[i];
			Object source = aGraph.getTerminal(currEdge, true);
			Object target = aGraph.getTerminal(currEdge, false);

			double dist = (Double) distanceMap.get(source) + costFunction.getCost(new mxCellState(view, currEdge, null));

			if (dist < (Double) distanceMap.get(target))
			{
				throw new StructuralException("The graph contains a negative cycle, so Bellman-Ford can't be completed.");
			}
		}

		List<Map<Object, Object>> result = new ArrayList<Map<Object, Object>>();
		result.add(distanceMap);
		result.add(parentMap);

		return result;
	};

	/**
	 * Implements the Floyd-Roy-Warshall (aka WFI) shortest path algorithm between all vertices.
	 *
	 * @param aGraph
	 * @return an ArrayList where ArrayList(0) is the distance map and List(1) is the path map. See the example in GraphConfigDialog.java
	 * @throws StructuralException - The Floyd-Roy-Warshall algorithm only works for graphs without negative cycles
	 */
	public static ArrayList<Object[][]> floydRoyWarshall(mxAnalysisGraph aGraph) throws StructuralException
	{

		Object[] vertices = aGraph.getChildVertices(aGraph.getGraph().getDefaultParent());
		Double[][] dist = new Double[vertices.length][vertices.length];
		Object[][] paths = new Object[vertices.length][vertices.length];
		Map<Object, Integer> indexMap = new HashMap<Object, Integer>();

		for (int i = 0; i < vertices.length; i++)
		{
			indexMap.put(vertices[i], i);
		}

		Object[] edges = aGraph.getChildEdges(aGraph.getGraph().getDefaultParent());
		dist = initializeWeight(aGraph, vertices, edges, indexMap);

		for (int k = 0; k < vertices.length; k++)
		{
			for (int i = 0; i < vertices.length; i++)
			{
				for (int j = 0; j < vertices.length; j++)
				{
					if (dist[i][j] > dist[i][k] + dist[k][j])
					{
						paths[i][j] = mxGraphStructure.getVertexWithValue(aGraph, k);
						dist[i][j] = dist[i][k] + dist[k][j];
					}
				}
			}
		}

		for (int i = 0; i < dist[0].length; i++)
		{
			if ((Double) dist[i][i] < 0)
			{
				throw new StructuralException("The graph has negative cycles");
			}
		}

		ArrayList<Object[][]> result = new ArrayList<Object[][]>();
		result.add(dist);
		result.add(paths);
		return result;
	};

	/**
	 * A helper function for the Floyd-Roy-Warshall algorithm - for internal use
	 * @param aGraph
	 * @param nodes
	 * @param edges
	 * @param indexMap
	 * @return
	 */
	private static Double[][] initializeWeight(mxAnalysisGraph aGraph, Object[] nodes, Object[] edges, Map<Object, Integer> indexMap)
	{
		Double[][] weight = new Double[nodes.length][nodes.length];

		for (int i = 0; i < nodes.length; i++)
		{
			Arrays.fill(weight[i], Double.MAX_VALUE);
		}

		boolean isDirected = mxGraphProperties.isDirected(aGraph.getProperties(), mxGraphProperties.DEFAULT_DIRECTED);
		mxCostFunction costFunction = aGraph.getGenerator().getCostFunction();
		mxGraphView view = aGraph.getGraph().getView();

		for (Object currEdge : edges)
		{
			Object source = aGraph.getTerminal(currEdge, true);
			Object target = aGraph.getTerminal(currEdge, false);

			weight[indexMap.get(source)][indexMap.get(target)] = costFunction.getCost(view.getState(currEdge));

			if (!isDirected)
			{
				weight[indexMap.get(target)][indexMap.get(source)] = costFunction.getCost(view.getState(currEdge));
			}
		}

		for (int i = 0; i < nodes.length; i++)
		{
			weight[i][i] = 0.0;
		}

		return weight;
	};

	/**
	 * This method helps the user to get the desired data from the result of the Floyd-Roy-Warshall algorithm.
	 * @param aGraph
	 * @param FWIresult - the result of the Floyd-Roy-Warhall algorithm
	 * @param startVertex
	 * @param targetVertex
	 * @return returns the shortest path from <b>startVertex</b> to <b>endVertex</b>
	 * @throws StructuralException - The Floyd-Roy-Warshall algorithm only works for graphs without negative cycles
	 */
	public static Object[] getWFIPath(mxAnalysisGraph aGraph, ArrayList<Object[][]> FWIresult, Object startVertex, Object targetVertex)
			throws StructuralException
	{
		Object[][] dist = FWIresult.get(0);
		Object[][] paths = FWIresult.get(1);
		ArrayList<Object> result = null;

		if (aGraph == null || paths == null || startVertex == null || targetVertex == null)
		{
			throw new IllegalArgumentException();
		}

		for (int i = 0; i < dist[0].length; i++)
		{
			if ((Double) dist[i][i] < 0)
			{
				throw new StructuralException("The graph has negative cycles");
			}
		}

		if (startVertex != targetVertex)
		{
			mxCostFunction cf = aGraph.getGenerator().getCostFunction();
			mxGraphView view = aGraph.getGraph().getView();
			ArrayList<Object> currPath = new ArrayList<Object>();
			currPath.add(startVertex);

			while (startVertex != targetVertex)
			{
				result = getWFIPathRec(aGraph, paths, startVertex, targetVertex, currPath, cf, view);
				startVertex = result.get(result.size() - 1);
			}
		}

		if (result == null)
		{
			result = new ArrayList<Object>();
		}

		return result.toArray();
	};

	/**
	 * Helper method for getWFIPath - for internal use
	 * @param aGraph
	 * @param paths
	 * @param startVertex
	 * @param targetVertex
	 * @param currPath
	 * @param cf
	 * @param view
	 * @return
	 * @throws StructuralException
	 */
	private static ArrayList<Object> getWFIPathRec(mxAnalysisGraph aGraph, Object[][] paths, Object startVertex, Object targetVertex,
			ArrayList<Object> currPath, mxCostFunction cf, mxGraphView view) throws StructuralException
	{
		Double sourceIndexD = (Double) cf.getCost(view.getState(startVertex));
		Object[] parents = paths[sourceIndexD.intValue()];
		Double targetIndexD = (Double) cf.getCost(view.getState(targetVertex));
		int tIndex = targetIndexD.intValue();

		if (parents[tIndex] != null)
		{
			currPath = getWFIPathRec(aGraph, paths, startVertex, parents[tIndex], currPath, cf, view);
		}
		else
		{
			if (mxGraphStructure.areConnected(aGraph, startVertex, targetVertex) || startVertex == targetVertex)
			{
				currPath.add(targetVertex);
			}
			else
			{
				throw new StructuralException("The two vertices aren't connected");
			}
		}

		return currPath;
	}
};