private void init(Graph<V, E> g, Set<V> vertexSet, Set<E> edgeSet) {
// create a map between vertex value to its order(1st,2nd,etc)
// "CAT"=1 "DOG"=2 "RHINO"=3
this.mapVertexToOrder = new HashMap<V, Integer>(vertexSet.size());
int counter = 0;
for (V vertex : vertexSet) {
mapVertexToOrder.put(vertex, new Integer(counter));
counter++;
}
// create a friendlier representation of an edge
// by order, like 2nd->3rd instead of B->A
// use the map to convert vertex to order
// on directed graph, edge A->B must be (A,B)
// on undirected graph, edge A-B can be (A,B) or (B,A)
this.labelsEdgesSet = new HashSet<LabelsEdge>(edgeSet.size());
for (E edge : edgeSet) {
V sourceVertex = g.getEdgeSource(edge);
Integer sourceOrder = mapVertexToOrder.get(sourceVertex);
int sourceLabel = sourceOrder.intValue();
int targetLabel = (mapVertexToOrder.get(g.getEdgeTarget(edge))).intValue();
LabelsEdge lablesEdge = new LabelsEdge(sourceLabel, targetLabel);
this.labelsEdgesSet.add(lablesEdge);
if (g instanceof UndirectedGraph<?, ?>) {
LabelsEdge oppositeEdge = new LabelsEdge(targetLabel, sourceLabel);
this.labelsEdgesSet.add(oppositeEdge);
}
}
}
/**
* @param vertexNumber the number which identifies the vertex v in this order.
* @return the identifying numbers of all vertices which are connected to v by an edge incoming to
* v.
*/
public int[] getInEdges(int vertexNumber) {
if (cacheEdges && (incomingEdges[vertexNumber] != null)) {
return incomingEdges[vertexNumber];
}
V v = getVertex(vertexNumber);
Set<E> edgeSet;
if (graph instanceof DirectedGraph<?, ?>) {
edgeSet = ((DirectedGraph<V, E>) graph).incomingEdgesOf(v);
} else {
edgeSet = graph.edgesOf(v);
}
int[] vertexArray = new int[edgeSet.size()];
int i = 0;
for (E edge : edgeSet) {
V source = graph.getEdgeSource(edge), target = graph.getEdgeTarget(edge);
vertexArray[i++] = mapVertexToOrder.get(source.equals(v) ? target : source);
}
if (cacheEdges) {
incomingEdges[vertexNumber] = vertexArray;
}
return vertexArray;
}
public int[] getEdgeNumbers(E e) {
V v1 = graph.getEdgeSource(e), v2 = graph.getEdgeTarget(e);
int[] edge = new int[2];
edge[0] = mapVertexToOrder.get(v1);
edge[1] = mapVertexToOrder.get(v2);
return edge;
}
/** Calculates the matrix of all shortest paths, but does not populate the paths map. */
private void lazyCalculateMatrix() {
if (d != null) {
// already done
return;
}
int n = vertices.size();
// init the backtrace matrix
backtrace = new int[n][n];
for (int i = 0; i < n; i++) {
Arrays.fill(backtrace[i], -1);
}
// initialize matrix, 0
d = new double[n][n];
for (int i = 0; i < n; i++) {
Arrays.fill(d[i], Double.POSITIVE_INFINITY);
}
// initialize matrix, 1
for (int i = 0; i < n; i++) {
d[i][i] = 0.0;
}
// initialize matrix, 2
Set<E> edges = graph.edgeSet();
for (E edge : edges) {
V v1 = graph.getEdgeSource(edge);
V v2 = graph.getEdgeTarget(edge);
int v_1 = vertices.indexOf(v1);
int v_2 = vertices.indexOf(v2);
d[v_1][v_2] = graph.getEdgeWeight(edge);
if (!(graph instanceof DirectedGraph<?, ?>)) {
d[v_2][v_1] = graph.getEdgeWeight(edge);
}
}
// run fw alg
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
double ik_kj = d[i][k] + d[k][j];
if (ik_kj < d[i][j]) {
d[i][j] = ik_kj;
backtrace[i][j] = k;
}
}
}
}
}
V getEdgeTarget(E e) {
return graph.getEdgeTarget(e);
}
