Java Graph类代码示例

import y.base.Graph; //导入依赖的package包/类
@Override
public double measure(Cover cover) throws InterruptedException {
	double metricValue = 0;
	Graph graph = cover.getGraph();
	NodeCursor nodesA = graph.nodes();
	NodeCursor nodesB = graph.nodes();
	Node nodeA;
	Node nodeB;
	while(nodesA.ok()) {
		nodeA = nodesA.node();
		nodesB.toFirst();
		while(nodesB.ok()) {
			nodeB = nodesB.node();
			metricValue +=
					getNodePairModularityContribution(cover, nodeA, nodeB);
			nodesB.next();
		}
			nodesA.next();
	}
	if(graph.edgeCount() > 0) {
		metricValue /= (graph.edgeCount() * 2);
	}
	return metricValue;
}
 

import y.base.Graph; //导入依赖的package包/类
private static void updatePairMap(Edge edge, Graph graph, Graph hyperGraph) {
	NodeMap pairMap = (NodeMap) graph
			.getDataProvider(NodeMapKeys.NODE2PAIR_NODE);
	EdgeMap edgeInfo = (EdgeMap) graph
			.getDataProvider(EdgeMapKeys.EDGE_INFO);
	NodeMap parentNodeMap = (NodeMap) graph
			.getDataProvider(NodeMapKeys.NODE2PARENT_HYPERNODE);
	NodeMap hyper2starting = (NodeMap) hyperGraph
			.getDataProvider(NodeMapKeys.HYPERNODE2STARTING_NODE);

	EditorEdgeInfoData info = (EditorEdgeInfoData) edgeInfo.get(edge);
	if (!info.isPair()) {
		return;
	}

	Node hyperSourceNode = (Node) parentNodeMap.get(edge.source());
	Node hyperTargetNode = (Node) parentNodeMap.get(edge.target());

	Node startingSource = (Node) hyper2starting.get(hyperSourceNode);
	Node startingTarget = (Node) hyper2starting.get(hyperTargetNode);

	pairMap.set(startingSource, startingTarget);
	pairMap.set(startingTarget, startingSource);
}
 

import y.base.Graph; //导入依赖的package包/类
public String getExtendedNotation(GraphManager graphManager) {

		Graph hyperGraph = graphManager.getHyperGraph();
		if (hyperGraph.isEmpty()) {
			return EMPTY_STRING;
		}

		StringBuilder notation = new StringBuilder();

		Map<Node, String> nameMap = new HashMap<Node, String>();
		Object[] args = new Object[] { hyperGraph, nameMap };

		for (NotationCreator currCreator : _creators) {
			notation.append(currCreator.createNotationPart(args));
		}
		notation.append(NOTATION_PART_ENDING);

		return notation.toString();
	}
 

import y.base.Graph; //导入依赖的package包/类
protected Node getSingleSuccessor(Node n) {
	EdgeCursor edgeCursor = n.outEdges();
	Graph g = n.getGraph();
	EdgeMap type = (EdgeMap) g.getDataProvider(EdgeMapKeys.EDGE_INFO);

	for (; edgeCursor.ok(); edgeCursor.next()) {
		Edge e = edgeCursor.edge();
		EdgeInfo info = (EdgeInfo) type.get(e);
		if (info.isRegular() && !MonomerInfoUtils.isInterPolymer(e)) {
			return e.opposite(n);
		}
	}

	return null;

}
 

import y.base.Graph; //导入依赖的package包/类
protected Edge getSingleOutEdge(Node n) {
	EdgeCursor edgeCursor = n.outEdges();
	Graph g = n.getGraph();
	EdgeMap type = (EdgeMap) g.getDataProvider(EdgeMapKeys.EDGE_INFO);

	for (; edgeCursor.ok(); edgeCursor.next()) {
		Edge e = edgeCursor.edge();
		EdgeInfo info = (EdgeInfo) type.get(e);
		if (info.isRegular()) {
			return e;
		}
	}

	return null;

}
 

import y.base.Graph; //导入依赖的package包/类
private boolean changeDirection(Graph graph, Node sourceNode,
		Node targetNode) {
	if (!sameSequence(graph, sourceNode, targetNode)) {
		return false;
	}

	NodeMap positions = (NodeMap) graph
			.getDataProvider(NodeMapKeys.MONOMER_POSITION);
	Integer spos = (Integer) positions.get(sourceNode);
	if (spos == null) {
		return false;
	}
	Integer tpos = (Integer) positions.get(targetNode);
	if (tpos == null) {
		return false;
	}
	return (spos < tpos);
}
 

import y.base.Graph; //导入依赖的package包/类
/**
 * test if a strand starting with the given starting node CAN pair up with a
 * new complementary strand
 * 
 * @param startingNode
 * @return true: if each of the base node has free hydrogen bond connection,
 *         otherwise false.
 * @throws org.helm.notation.MonomerException
 * @throws org.jdom.JDOMException
 * @throws java.io.IOException
 */
private boolean hasComplementary(Node startingNode)
		throws MonomerException, JDOMException, IOException {
	NodeList baseList = SequenceGraphTools.getBaseList(startingNode,
			view.getGraph2D(), false);
	Node base = null;
	final Graph graph = view.getGraph2D();
	NodeMap nodeMap = (NodeMap) graph
			.getDataProvider(NodeMapKeys.MONOMER_REF);
	MonomerInfo monomerInfo = null;

	while (!baseList.isEmpty()) {
		base = baseList.popNode();
		monomerInfo = (MonomerInfo) nodeMap.get(base);
		if (monomerInfo.isConnected(monomerInfo
				.getAttachment(Attachment.PAIR_ATTACHMENT))) {
			return false;
		}
	}

	return true;

}
 

import y.base.Graph; //导入依赖的package包/类
private void releaseConnection(Edge edge) {
	Graph graph = edge.getGraph();
	EdgeMap edgeMap = (EdgeMap) graph
			.getDataProvider(EdgeMapKeys.EDGE_INFO);
	NodeMap nodeMap = (NodeMap) graph
			.getDataProvider(NodeMapKeys.MONOMER_REF);

	EditorEdgeInfoData edgeInfoData = (EditorEdgeInfoData) edgeMap
			.get(edge);
	if (edgeInfoData == null) {
		return;
	}

	MonomerInfo sourceMonomerInfo = (MonomerInfo) nodeMap
			.get(edge.source());
	MonomerInfo targetMonomerInfo = (MonomerInfo) nodeMap
			.get(edge.target());

	sourceMonomerInfo.setConnection(edgeInfoData.getSourceNodeAttachment(),
			false);
	targetMonomerInfo.setConnection(edgeInfoData.getTargetNodeAttachment(),
			false);
}
 

import y.base.Graph; //导入依赖的package包/类
private boolean breaksComponent(Edge e) {
	Graph g = e.getGraph();
	NodeMap hyper = (NodeMap) g
			.getDataProvider(NodeMapKeys.NODE2PARENT_HYPERNODE);
	NodeMap starting = (NodeMap) g
			.getDataProvider(NodeMapKeys.NODE2STARTING_NODE);
	if (hyper.get(e.source()) != hyper.get(e.target())) {
		// edge connects two different components,
		// so need to add another one
		return false;
	}

	GraphHider gh = new GraphHider(g);
	gh.hide(e);

	Node s = (Node) starting.get(e.source());
	NodeList accessibleNodes = GraphConnectivity.getSuccessors(g,
			new NodeList(s), g.N());
	// check if we still can access target node
	gh.unhideAll();
	return !accessibleNodes.contains(e.target());
}
 

import y.base.Graph; //导入依赖的package包/类
private List<Node> getPaired(Node startNode) {
	NodeMap parentNodeMap = (NodeMap) graph
			.getDataProvider(NodeMapKeys.NODE2PARENT_HYPERNODE);
	Graph hyperGraph = manager.getHyperGraph();
	EdgeMap hyperEdgeDescMap = (EdgeMap) hyperGraph
			.getDataProvider(EdgeMapKeys.DESCRIPTION);
	List<Node> startingNodeList = manager.getStartingNodeList();
	List<Node> result = new ArrayList<Node>();

	Node hyperNode1 = (Node) parentNodeMap.get(startNode);
	for (Node aStartingNodeList : startingNodeList) {
		Node hyperNode2 = (Node) parentNodeMap.get(aStartingNodeList);
		Edge hyperEdge = hyperNode1.getEdge(hyperNode2);
		if (hyperEdge != null) {
			String edgeDesc = (String) hyperEdgeDescMap.get(hyperEdge);
			if (edgeDesc.contains("pair")) {
				result.add(aStartingNodeList);
			}
		}
	}
	return result;
}
 

import y.base.Graph; //导入依赖的package包/类
private static Node createTypeNode(final BaseType baseType, final Graph graph,
    final BiMap<BaseType, Node> map) {
  final Node node = map.get(baseType);
  if (node == null) {
    final Node newNode = graph.createNode();
    map.put(baseType, newNode);
    return newNode;
  } else {
    return node;
  }
}
 

import y.base.Graph; //导入依赖的package包/类
@Override
public void reInsertBend(final Bend bend, final Bend refBend, final int dir) {

  final int index = ((bendPos(refBend) + dir) == Graph.BEFORE) || (refBend == null) ? 0 : 1;

  super.reInsertBend(bend, refBend, dir);

  for (final IZyEdgeRealizerListener<EdgeType> listener : m_listeners) {
    try {
      listener.insertedBend(index, bend.getX(), bend.getY());
    } catch (final Exception exception) {
      exception.printStackTrace();
    }
  }
}
 

import y.base.Graph; //导入依赖的package包/类
@Override
public double measure(Cover cover) throws InterruptedException {
	double metricValue = 0;
	Graph graph = cover.getGraph();
	NodeCursor nodesA = graph.nodes();
	NodeCursor nodesB = graph.nodes();
	Node nodeA;
	Node nodeB;
	while(nodesA.ok()) {
		nodeA = nodesA.node();
		nodesB.toFirst();
		while(nodesB.ok()) {
			nodeB = nodesB.node();
			if(nodeB.index() > nodeA.index()) {
				break;
			}
			metricValue +=
					getNodePairModularityContribution(cover, nodesA.node(), nodesB.node());
			nodesB.next();
		}
			nodesA.next();
	}
	if(graph.edgeCount() > 0) {
		metricValue /= graph.edgeCount();
	}
	return metricValue;
}
 

import y.base.Graph; //导入依赖的package包/类
/**
 * set up a graph copier for a given graph
 * 
 * @param graph
 * @return a GraphCopier object
 */
public static GraphCopier getGraphCopier(Graph graph) {
	GraphCopier copier = new GraphCopier(graph.getGraphCopyFactory());
	copier.setDataProviderContentCopying(true);
	copier.setEdgeMapCopying(true);
	copier.setNodeMapCopying(true);

	return copier;
}
 

import y.base.Graph; //导入依赖的package包/类
public static boolean checkDistance(Node node1, Node node2, Graph graph,
		boolean ifPairEdgeAdded) {
	GraphHider graphHider = null;
	if (ifPairEdgeAdded) {
		// hide pair edges and find all sequences
		graphHider = new GraphHider(graph);
		for (Edge edge : graph.getEdgeArray()) {
			DataProvider edgeTypeMap = graph
					.getDataProvider(EdgeMapKeys.EDGE_INFO);
			if (((EdgeInfo) edgeTypeMap.get(edge)).isPair()) {
				graphHider.hide(edge);
			}
		}
	}

	NodeList neighbours = GraphConnectivity.getNeighbors(graph,
			new NodeList(node1),
			ifPairEdgeAdded ? MINIMAL_DISTANCE_PAIRED_NODES
					: MINIMAL_NODES_DISTANCE);

	if (ifPairEdgeAdded) {
		graphHider.unhideAll();
	}

	// if neighbours contains node2 then the distance is less than
	// acceptable
	return !neighbours.contains(node2);
}