Java Graph.edgesOf方法代碼示例

import org.jgrapht.Graph; //導入方法依賴的package包/類
/**
 * 
 * @param g
 * @param newVertex
 * @param connectedVertices
 */
public static <V,E> void expandConnectedVertices(Graph<V,E> g, V newVertex, Set<V> connectedVertices){
	//for every edge (ignoring direction) connected newVertex
	for(E edge : g.edgesOf(newVertex)){
		V connectedVertex; //find the other vertex connected to newVertex
		if(g.getEdgeSource(edge).equals(newVertex)){
			connectedVertex = g.getEdgeTarget(edge);
		} else {
			connectedVertex = g.getEdgeSource(edge);
		}
		if(!connectedVertices.contains(connectedVertex)){ //if this vertex is not in connectedVertices
			connectedVertices.add(connectedVertex); //add it and search for more connected Vertices
			expandConnectedVertices(g, connectedVertex, connectedVertices);
		}
	}
}
 

import org.jgrapht.Graph; //導入方法依賴的package包/類
public static <T extends Object> boolean replaceVertex(Graph<T, DefaultEdge> completeGraph, T oldVertex, T newVertex) {
    if ((oldVertex == null) || (newVertex == null)) {
        return false;
    }
    final Set<DefaultEdge> relatedEdges = completeGraph.edgesOf(oldVertex);
    completeGraph.addVertex(newVertex);

    T sourceVertex;
    T targetVertex;
    for (DefaultEdge e : relatedEdges) {
        sourceVertex = completeGraph.getEdgeSource(e);
        targetVertex = completeGraph.getEdgeTarget(e);
        if (sourceVertex.equals(oldVertex)
                && targetVertex.equals(oldVertex)) {
            completeGraph.addEdge(newVertex, newVertex);
        } else {
            if (sourceVertex.equals(oldVertex)) {
                completeGraph.addEdge(newVertex, targetVertex);
            } else {
                completeGraph.addEdge(sourceVertex, newVertex);
            }
        }
    }
    completeGraph.removeVertex(oldVertex);
    return true;
}
 

import org.jgrapht.Graph; //導入方法依賴的package包/類
protected INDArray buildAdjacencyMatrix(Graph<V, E> graph, Map<V, Integer> index) {
    final double[][] matrix = new double[graph.vertexSet().size()][graph.vertexSet().size()];

    for (Map.Entry<V, Integer> entry : index.entrySet()) {
        for (final E edge : graph.edgesOf(entry.getKey())) {
            final V neighbor = Graphs.getOppositeVertex(graph, edge, entry.getKey());
            matrix[entry.getValue()][index.get(neighbor)] = graph.getEdgeWeight(edge);
        }
    }

    for (int r = 0; r < matrix.length; r++) matrix[r][r] = 1;

    return Nd4j.create(matrix);
}
 

import org.jgrapht.Graph; //導入方法依賴的package包/類
private List<Path> getPathsFromGraphHopper(Graph<AutomatVertex, DefaultEdge> completeGraph) {
        LOG.info("--- getPathsFromGraphHopper ---");

        final Set<AutomatEdge> automatEdges = Sets.newHashSet();
        final Iterator<AutomatVertex> graphIterator = new DepthFirstIterator<>(completeGraph);
        while (graphIterator.hasNext()) {
            final AutomatVertex vertex = graphIterator.next();
            Set<DefaultEdge> edges = completeGraph.edgesOf(vertex);

            for (DefaultEdge edge : edges) {
                AutomatVertex source = completeGraph.getEdgeSource(edge);
                AutomatVertex target = completeGraph.getEdgeTarget(edge);
                automatEdges.add(new AutomatEdge(source, target));
            }
        }

        final List<Path> paths = Lists.newArrayList();

        final int count = automatEdges.size();
        int idx = 0;
        int errors = 0;
        final StopWatch stopWatch = new StopWatch("route");
        for (AutomatEdge automatEdge : automatEdges) {
//            if (idx == 10) break;
            stopWatch.start();
            final Path computedPath = graphHopperGetPath(automatEdge.source, automatEdge.target);
            if (computedPath != null) {
                paths.add(computedPath);
            } else {
                errors++;
            }
            stopWatch.stop();
            if (idx % 1000 == 0) {
                LOG.info(String.format("%.2f %s", (float) idx / (float) count * 100.0f, "%"));
            }
            idx++;
        }
        LOG.info(String.format("%.2f %s", (float) idx / (float) count * 100.0f, "%"));
        LOG.info(stopWatch.shortSummary());
        if (errors > 0) {
            LOG.error("Errors count is {} which is {} from all data {}", errors, String.format("%.4f %s", (float) errors / (float) automatEdges.size() * 100.0f, "%"), automatEdges.size());
        }
        return paths;
    }