import org.jgrapht.graph.Pseudograph; //导入依赖的package包/类
private GKAGraph(GraphType type){
	this.type = type;
	
	// Choose if it will be directed or undirected
	if (isDirected()){
		jGraph = new ListenableDirectedGraph<>(new DirectedPseudograph<>(GKAEdge.class));
	}else{
		jGraph = new ListenableUndirectedGraph<>(new Pseudograph<>(GKAEdge.class));
	}
	
	// JGXAdapter for showing the Graph in Swing
	mxgraph = new JGraphXAdapter<>(getjGraph());
	
	// Changing EdgeStyle when is undirected
	if (!isDirected()){
		getMxgraph().getStylesheet().getDefaultEdgeStyle().put(mxConstants.STYLE_ENDARROW, "none");
	}
	setGraphConfig();
}
 

import org.jgrapht.graph.Pseudograph; //导入依赖的package包/类
public Graph(GeometryCollection lines) {
    graph = new Pseudograph<>(LineString.class);
    int nLines = lines.getNumGeometries();
    for (int i = 0; i < nLines; i++) {
        LineString line = (LineString) lines.getGeometryN(i);
        addEdge(line);
    }
    fixConnectivity();

    assert (testConnectivity());
}
 

import org.jgrapht.graph.Pseudograph; //导入依赖的package包/类
/**
 * Base constructor.
 */
public DataSet() {
    this.superNetwork = new Variable<SuperNetwork>(new SuperNetwork(null, new Pseudograph<HNode, DefaultEdge>(DefaultEdge.class)));
    this.nodeMap = new Variable<Map<CyNode, HNode>>(new HashMap<CyNode, HNode>());
    this.minScore = new Variable<Double>(0.);
    this.maxScore = new Variable<Double>(1.);
    this.categories = new Variable<Map<String, HCategory>>(new HashMap<String, HCategory>());
    this.setMap = new Variable<Map<CyNode, HSet>>(new HashMap<CyNode, HSet>());
}
 

import org.jgrapht.graph.Pseudograph; //导入依赖的package包/类
public Model() {
    this.selection = new Selection(this);
    this.openedCategories = new VolatileSet<HCategory>();
    this.orderedCategories =
            new Variable<List<HCategory>>(Collections.<HCategory>emptyList());
    this.highlightedProteins = new VolatileSet<HNode>();
    this.highlightedInteractions = new VolatileSet<DefaultEdge>();
    this.highlightedSets = new VolatileSet<HSet>();
    this.activeNetwork = new Variable<Network>(new SuperNetwork(null,
                            new Pseudograph<HNode, DefaultEdge>(DefaultEdge.class)));
    this.selectionMode = Constants.Selection.NONE;
}
 

import org.jgrapht.graph.Pseudograph; //导入依赖的package包/类
/**
 * Construct the complete undirected distance graph G1=(V1,EI,d1) from G and S.
 * @return
 */
private Pseudograph<Node, DefaultLink> step1() {
	
	logger.debug("<enter");

	Pseudograph<Node, DefaultLink> g = 
		new Pseudograph<Node, DefaultLink>(DefaultLink.class);
	
	for (Node n : this.steinerNodes) {
		g.addVertex(n);
	}
	
	BellmanFordShortestPath<Node, DefaultLink> path;
	
	for (Node n1 : this.steinerNodes) {
		path = new BellmanFordShortestPath<Node, DefaultLink>(this.graph, n1);
		
		for (Node n2 : this.steinerNodes) {
			
			if (n1.equals(n2))
				continue;
			
			if (g.containsEdge(n1, n2))
				continue;
			
			DefaultLink e = new DefaultLink();
			g.addEdge(n1, n2, e);
			g.setEdgeWeight(e, path.getCost(n2));
			
		}

	}
	
	logger.debug("exit>");

	return g;

}
 

import org.jgrapht.graph.Pseudograph; //导入依赖的package包/类
/**
	 * Find the minimal spanning tree, T1, of G1. (If there are several minimal spanning trees, pick an arbitrary one.)
	 * @param g1
	 * @return
	 */
	private WeightedMultigraph<Node, DefaultLink> step2(Pseudograph<Node, DefaultLink> g1) {

		logger.debug("<enter");

		KruskalMinimumSpanningTree<Node, DefaultLink> mst =
            new KruskalMinimumSpanningTree<Node, DefaultLink>(g1);

//    	logger.debug("Total MST Cost: " + mst.getSpanningTreeCost());

        Set<DefaultLink> edges = mst.getEdgeSet();

		WeightedMultigraph<Node, DefaultLink> g2 = 
			new WeightedMultigraph<Node, DefaultLink>(DefaultLink.class);
		
		List<DefaultLink> edgesSortedById = new ArrayList<DefaultLink>();
		
		for (DefaultLink e : edges) 
			edgesSortedById.add(e);
		
		Collections.sort(edgesSortedById);
		
		for (DefaultLink edge : edgesSortedById) {
			g2.addVertex(edge.getSource());
			g2.addVertex(edge.getTarget());
			g2.addEdge( edge.getSource(), edge.getTarget(), edge); 
		}
		
		logger.debug("exit>");

		return g2;
	}