/** * Adds a given node to the current graph. * @param node node to add to the graph * @return true if the node is added */ public boolean addNode(Node node) { try { int rowId = graph.addVertex(); for (int i = 0; i < node.getSchema().getColumnCount(); i++) { if (nodeSchema.hasColumn(node.getSchema().getColumnName(i))) { TypedFormat format = formatFactory.getFormat( node.getSchema().getColumnType(i).getSimpleName()); StringBuffer v = format.format(node.get(i), new StringBuffer(), new FieldPosition(0)); graph.getVertexTable().setValueAt(v.toString(), rowId, graph.getVertexTable().indexOf( node.getSchema().getColumnName(i))); } } nodeToId.put(node, rowId); fireNetworkEvent(node.getRow(), node.getRow(), 0, NetworkListener.INSERT_NODE); return true; } catch (Exception e) { throw new ObviousRuntimeException(e); } }
/** * Removes a node. * @param node node to remove * @return true if removed */ public boolean removeNode(Node node) { try { if (!nodeToId.containsValue(node.getRow())) { return false; } graph.removeVertex(node.getRow()); nodeToId.remove(node); fireNetworkEvent(node.getRow(), node.getRow(), 0, NetworkListener.DELETE_NODE); return true; } catch (Exception e) { e.printStackTrace(); throw new ObviousRuntimeException(e); } }
prefEdge = graph.addEdge(graph.getNode(source.getRow()), graph.getNode(target.getRow())); } else { prefEdge = graph.addEdge(graph.getNodeFromKey(source.getInt(nodeKey)), graph.getNodeFromKey(target.getInt(nodeKey))); prefEdge.set(colName, source.get(nodeKey)); } else if (graphCol && edge.get(colName).equals(targetKey) && nodeKey != null) { prefEdge.set(colName, target.get(nodeKey)); } else if (graphCol && edge.get(colName).equals(sourceKey) && nodeKey == null) { prefEdge.set(colName, source.getRow()); } else if (graphCol && edge.get(colName).equals(targetKey) && nodeKey == null) { prefEdge.set(colName, target.getRow()); } else { prefEdge.set(colName, edge.get(colName));
/** * Adds a given node to the current graph. * @param node node to add to the graph * @return true if the node is added */ public boolean addNode(Node node) { try { // if prefNode (prefuse) tuple and node (obvious) tuple are compatible // i.e their schema are compatible. prefuse.data.Node prefNode = this.graph.addNode(); for (int i = 0; i < node.getTable().getSchema().getColumnCount(); i++) { prefNode.set(node.getSchema().getColumnName(i), node.get(i)); } int nodeId = prefNode.getRow(); fireNetworkEvent(nodeId, nodeId, 0, NetworkListener.INSERT_NODE); return true; } catch (Exception e) { throw new ObviousRuntimeException(e); } }
/** * Loads the table with the data of external CSV files. * @return an obvious network * @throws ObviousxException when exception occurs */ public Network loadGraph() throws ObviousxException { CSVTableImport nodeImport = new CSVTableImport(nodeFile, new TableImpl(nodeSchema), separator); CSVTableImport edgeImport = new CSVTableImport(edgeFile, new TableImpl(edgeSchema), separator); Table nodeTable = nodeImport.loadTable(); Table edgeTable = edgeImport.loadTable(); for (int i = 0; i < nodeTable.getRowCount(); i++) { Node node = new NodeImpl(nodeTable, i); network.addNode(node); if (nodeId == null) { idToNode.put(node.getRow(), node); } else { idToNode.put(node.get(nodeId), node); } } for (int i = 0; i < edgeTable.getRowCount(); i++) { Edge edge = new EdgeImpl(edgeTable, i); network.addEdge(edge, idToNode.get(edge.get(sourceCol)), idToNode.get(edge.get(targetCol)), network.getEdgeType(edge)); } return this.network; }
/** * Gets the id of an input node. * @param node a node of the graph * @return id of the node */ private Integer getNodeId(Node node) { Integer id = null; for (Map.Entry<Node, Integer> e : nodeToId.entrySet()) { boolean nodeEquals = true; for (int i = 0; i < nodeSchema.getColumnCount(); i++) { String colName = nodeSchema.getColumnName(i); if (!node.get(colName).equals(e.getKey().get(colName))) { nodeEquals = false; break; } } if (nodeEquals) { id = e.getValue(); break; } } return id; }
/** * Converts an Obvious tree to an infovis tree. * @param tree tree to convert * @return the converted infovis tree */ private infovis.Tree convertToIvtkTree(Tree<Node, Edge> tree) { if (tree.getEdges().size() != 0 && tree.getNodes().size() != 0) { Schema nodeSchema = tree.getNodes().iterator().next().getSchema() .getDataSchema(); Schema edgeSchema = tree.getEdges().iterator().next().getSchema() .getDataSchema(); Tree<Node, Edge> ivtkTree = new IvtkObviousTree(nodeSchema, edgeSchema); ObviousLib.fillTree(tree, ivtkTree); return (infovis.Tree) ivtkTree.getUnderlyingImpl(infovis.Tree.class); } else { throw new ObviousRuntimeException("Empty tree!"); } }
@SuppressWarnings("unchecked") @Override public Iterator nodes() { Collection<obvious.data.Node> obvNodes = network.getNodes(); ArrayList<Node> prefNodes = new ArrayList<Node>(); for (obvious.data.Node node : obvNodes) { prefNodes.add(new WrapToPrefNode(network, (TupleImpl) node, node.getRow())); } return prefNodes.iterator(); }
/** * Gets the id of an input node. * @param node a node of the graph * @return id of the node */ private Integer getNodeId(Node node) { Integer id = null; for (Map.Entry<Node, Integer> e : nodeToId.entrySet()) { boolean nodeEquals = true; for (int i = 0; i < nodeSchema.getColumnCount(); i++) { String colName = nodeSchema.getColumnName(i); if (!node.get(colName).equals(e.getKey().get(colName))) { nodeEquals = false; break; } } if (nodeEquals) { id = e.getValue(); break; } } return id; }
/** * Constructor. * @param inNetwork obvious network to wrap */ public WrapToPrefGraph(Network inNetwork) { super(new WrapToPrefTable(inNetwork.getNodeTable()), new WrapToPrefTable(inNetwork.getEdgeTable()), true); this.network = inNetwork; if (network.getNodes().size() != 0) { this.nodeSchema = network.getNodes().iterator().next().getSchema(); } if (network.getEdges().size() != 0) { this.edgeSchema = network.getEdges().iterator().next().getSchema(); } m_nodeTuples = new TupleManager(getNodeTable(), this, Table.class); m_edgeTuples = new TupleManager(getEdgeTable(), this, Table.class); }
@SuppressWarnings("unchecked") @Override public Iterator inNeighbors(Node n) { Collection<obvious.data.Node> obvNodes = network.getPredecessors( getObviousNode(n)); ArrayList<Node> prefNodes = new ArrayList<Node>(); for (obvious.data.Node node : obvNodes) { prefNodes.add(new WrapToPrefNode(network, (TupleImpl) node, node.getRow())); } return prefNodes.iterator(); }
TypedFormat format = formatFactory.getFormat( nodeSchema.getColumnType(i).getSimpleName()); StringBuffer value = format.format(node.get(i), new StringBuffer(), new FieldPosition(0)); serializer.writeCharacters(value.toString());
@SuppressWarnings("unchecked") @Override public Iterator neighbors(Node n) { Collection<obvious.data.Node> obvNodes = network.getNeighbors( getObviousNode(n)); ArrayList<Node> prefNodes = new ArrayList<Node>(); for (obvious.data.Node node : obvNodes) { prefNodes.add(new WrapToPrefNode(network, (TupleImpl) node, node.getRow())); } return prefNodes.iterator(); }
network.addNode(node); for (Node n : network.getNodes()) { if (n.get(nodeId).equals(id)) { node = n; break;
@SuppressWarnings("unchecked") @Override public Iterator outNeighbors(Node n) { Collection<obvious.data.Node> obvNodes = network.getSuccessors( getObviousNode(n)); ArrayList<Node> prefNodes = new ArrayList<Node>(); for (obvious.data.Node node : obvNodes) { prefNodes.add(new WrapToPrefNode(network, (TupleImpl) node, node.getRow())); } return prefNodes.iterator(); }
@Override public int getTargetNode(int edge) { return network.getTarget(getObviousEdge(edge)).getRow(); }
@Override public int getSourceNode(int edge) { return network.getSource(getObviousEdge(edge)).getRow(); }
/** * Gets incident edges for a spotted node. * @param node spotted * @return collection of incident edges */ @SuppressWarnings("unchecked") public Collection<Edge> getIncidentEdges(Node node) { Collection<Edge> edge = new ArrayList<Edge>(); prefuse.data.Node prefNode = this.graph.getNodeFromKey( this.graph.getKey(node.getRow())); Iterator<Edge> i = this.graph.edges(prefNode); while (i.hasNext()) { edge.add(new PrefuseObviousEdge((prefuse.data.Edge) i.next())); } return edge; }
/** * Get out-linking edges for a specific node. * @param node spotted node * @return collection of out-linking edges */ @SuppressWarnings("unchecked") public Collection<Edge> getOutEdges(Node node) { Collection<Edge> outEdge = new ArrayList<Edge>(); prefuse.data.Node prefNode = this.graph.getNodeFromKey( this.graph.getKey(node.getRow())); Iterator<Edge> i = this.graph.outEdges(prefNode); while (i.hasNext()) { outEdge.add(new PrefuseObviousEdge((prefuse.data.Edge) i.next())); } return outEdge; }
/** * Gets in-linking edges for a specific node. * @param node spotted node * @return collection of in-linking edges */ @SuppressWarnings("unchecked") public Collection<Edge> getInEdges(Node node) { Collection<Edge> inEdge = new ArrayList<Edge>(); prefuse.data.Node prefNode = this.graph.getNodeFromKey( this.graph.getKey(node.getRow())); Iterator<Edge> i = this.graph.inEdges(prefNode); while (i.hasNext()) { inEdge.add(new PrefuseObviousEdge((prefuse.data.Edge) i.next())); } return inEdge; }