private void updateNodes(HierarchicalGraph graph) {
Modeler nodeInit = engine.getModelClasses()[AbstractEngine.CLASS_NODE].getCurrentModeler();
NodeIterable nodeIterable;
nodeIterable = graph.getNodes();
for (Node node : nodeIterable) {
Model obj = node.getNodeData().getModel();
if (obj == null) {
// Model is null, ADD
obj = nodeInit.initModel(node.getNodeData());
engine.addObject(AbstractEngine.CLASS_NODE, (ModelImpl) obj);
} else if (!obj.isValid()) {
engine.addObject(AbstractEngine.CLASS_NODE, (ModelImpl) obj);
}
obj.setCacheMarker(cacheMarker);
// Modeaction
if (modeManager.getMode().equals(ModeManager.AVAILABLE_MODES.HIGHLIGHT)) {
ModelImpl impl = (ModelImpl) obj;
// if (!node.isVisible()) {
// ColorLayer.layerColor(impl, 0.8f, 0.8f, 0.8f);
// }
}
}
}
private void writeListNode(Node node, boolean writeSeparator) throws IOException {
String label = node.getNodeData().getLabel();
if (label == null) {
label = node.getNodeData().getId();
}
writer.append(label);
if (writeSeparator) {
writer.append(SEPARATOR);
}
}
public void script() {
// Init a project - and therefore a workspace
ProjectController pc = Lookup.getDefault().lookup(ProjectController.class);
pc.newProject();
Workspace workspace = pc.getCurrentWorkspace();
// Get controllers and models
ImportController importController = Lookup.getDefault().lookup(ImportController.class);
// Import file
Container container;
try {
File file =
new File(
getClass().getResource("/org/gephi/toolkit/demos/resources/polblogs.gml").toURI());
container = importController.importFile(file);
container.getLoader().setEdgeDefault(EdgeDefault.DIRECTED); // Force DIRECTED
container.setAllowAutoNode(false); // Don't create missing nodes
} catch (Exception ex) {
ex.printStackTrace();
return;
}
// Append imported data to GraphAPI
importController.process(container, new DefaultProcessor(), workspace);
// List node columns
AttributeController ac = Lookup.getDefault().lookup(AttributeController.class);
AttributeModel model = ac.getModel();
for (AttributeColumn col : model.getNodeTable().getColumns()) {
System.out.println(col);
}
// Add boolean column
AttributeColumn testCol = model.getNodeTable().addColumn("test", AttributeType.BOOLEAN);
// Write values to nodes
GraphModel graphModel = Lookup.getDefault().lookup(GraphController.class).getModel();
for (Node n : graphModel.getGraph().getNodes()) {
n.getNodeData().getAttributes().setValue(testCol.getIndex(), Boolean.TRUE);
}
// Iterate values - fastest
AttributeColumn sourceCol = model.getNodeTable().getColumn("source");
for (Node n : graphModel.getGraph().getNodes()) {
System.out.println(n.getNodeData().getAttributes().getValue(sourceCol.getIndex()));
}
// Iterate values - normal
for (Node n : graphModel.getGraph().getNodes()) {
System.out.println(n.getNodeData().getAttributes().getValue("source"));
}
}
private void writeNodeColor(XMLStreamWriter xmlWriter, Node node) throws Exception {
int r = Math.round(node.getNodeData().r() * 255f);
int g = Math.round(node.getNodeData().g() * 255f);
int b = Math.round(node.getNodeData().b() * 255f);
if (r != 0 || g != 0 || b != 0) {
xmlWriter.writeStartElement(VIZ, NODE_COLOR, VIZ_NAMESPACE);
xmlWriter.writeAttribute("r", "" + r);
xmlWriter.writeAttribute("g", "" + g);
xmlWriter.writeAttribute("b", "" + b);
xmlWriter.writeEndElement();
}
}
private void writeNodes(XMLStreamWriter xmlWriter, HierarchicalGraph graph) throws Exception {
if (cancel) {
return;
}
xmlWriter.writeStartElement(NODES);
AttributeColumn dynamicCol =
dynamicCol = attributeModel.getNodeTable().getColumn(DynamicModel.TIMEINTERVAL_COLUMN);
NodeIterable nodeIterable = exportHierarchy ? graph.getNodesTree() : graph.getNodes();
for (Node node : nodeIterable) {
xmlWriter.writeStartElement(NODE);
String id = node.getNodeData().getId();
xmlWriter.writeAttribute(NODE_ID, id);
if (node.getNodeData().getLabel() != null && !node.getNodeData().getLabel().isEmpty()) {
xmlWriter.writeAttribute(NODE_LABEL, node.getNodeData().getLabel());
}
if (exportHierarchy) {
Node parent = graph.getParent(node);
if (parent != null) {
xmlWriter.writeAttribute(NODE_PID, parent.getNodeData().getId());
}
}
if (exportDynamic && dynamicCol != null && visibleInterval != null) {
TimeInterval timeInterval =
(TimeInterval) node.getNodeData().getAttributes().getValue(dynamicCol.getIndex());
if (timeInterval != null) {
writeTimeInterval(xmlWriter, timeInterval);
}
}
if (exportAttributes && node.getNodeData().getAttributes() != null) {
AttributeRow attributeRow = (AttributeRow) node.getNodeData().getAttributes();
writeAttValues(xmlWriter, attributeRow, visibleInterval);
}
if (exportSize) {
writeNodeSize(xmlWriter, node);
}
if (exportPosition) {
writeNodePosition(xmlWriter, node);
}
if (exportColors) {
writeNodeColor(xmlWriter, node);
}
xmlWriter.writeEndElement();
Progress.progress(progress);
if (cancel) {
break;
}
}
xmlWriter.writeEndElement();
}
private void writeNodeSize(XMLStreamWriter xmlWriter, Node node) throws Exception {
xmlWriter.writeStartElement(VIZ, NODE_SIZE, VIZ_NAMESPACE);
float size = node.getNodeData().getSize();
if (normalize) {
size = (size - minSize) / (maxSize - minSize);
}
xmlWriter.writeAttribute("value", "" + size);
xmlWriter.writeEndElement();
}
public void coarsen(HierarchicalGraph g) {
HierarchicalGraph graph = g;
int retract = 0;
int count = 0;
for (Edge e : graph.getEdgesAndMetaEdges().toArray()) {
Node a = e.getSource();
Node b = e.getTarget();
count++;
if (graph.getParent(a) == graph.getParent(b) && graph.getLevel(a) == 0) {
float x = (a.getNodeData().x() + b.getNodeData().x()) / 2;
float y = (a.getNodeData().y() + b.getNodeData().y()) / 2;
Node parent = graph.groupNodes(new Node[] {a, b});
parent.getNodeData().setX(x);
parent.getNodeData().setY(y);
graph.retract(parent);
retract++;
}
}
}
public void refine(HierarchicalGraph graph) {
double r = 10;
int count = 0;
int refined = 0;
for (Node node : graph.getTopNodes().toArray()) {
count++;
if (graph.getChildrenCount(node) == 2) {
refined++;
float x = node.getNodeData().x();
float y = node.getNodeData().y();
for (Node child : graph.getChildren(node)) {
double t = Math.random();
child.getNodeData().setX((float) (x + r * Math.cos(t)));
child.getNodeData().setY((float) (y + r * Math.sin(t)));
}
graph.ungroupNodes(node);
}
}
// System.out.println("COUNT = " + count);
// System.out.println("REFINED = " + refined);
}
private void writeNodePosition(XMLStreamWriter xmlWriter, Node node) throws Exception {
float x = node.getNodeData().x();
if (normalize && x != 0.0) {
x = (x - minX) / (maxX - minX);
}
float y = node.getNodeData().y();
if (normalize && y != 0.0) {
y = (y - minY) / (maxY - minY);
}
float z = node.getNodeData().z();
if (normalize && z != 0.0) {
z = (z - minZ) / (maxZ - minZ);
}
if (!(x == 0 && y == 0 && z == 0)) {
xmlWriter.writeStartElement(VIZ, NODE_POSITION, VIZ_NAMESPACE);
xmlWriter.writeAttribute("x", "" + x);
xmlWriter.writeAttribute("y", "" + y);
if (z != 0) {
xmlWriter.writeAttribute("z", "" + z);
}
xmlWriter.writeEndElement();
}
}
public void groupCluster(Cluster cluster) {
GraphModel gm = Lookup.getDefault().lookup(GraphController.class).getModel();
if (gm != null) {
HierarchicalGraph graph = gm.getHierarchicalGraphVisible();
Node[] newGroup = cluster.getNodes();
float centroidX = 0;
float centroidY = 0;
int len = 0;
Node group = graph.groupNodes(newGroup);
cluster.setMetaNode(group);
group.getNodeData().setLabel("Group");
group.getNodeData().setSize(10f);
for (Node child : newGroup) {
centroidX += child.getNodeData().x();
centroidY += child.getNodeData().y();
len++;
}
centroidX /= len;
centroidY /= len;
group.getNodeData().setX(centroidX);
group.getNodeData().setY(centroidY);
}
}
private void calculateMinMax(Graph graph) {
minX = Float.POSITIVE_INFINITY;
maxX = Float.NEGATIVE_INFINITY;
minY = Float.POSITIVE_INFINITY;
maxY = Float.NEGATIVE_INFINITY;
minZ = Float.POSITIVE_INFINITY;
maxZ = Float.NEGATIVE_INFINITY;
minSize = Float.POSITIVE_INFINITY;
maxSize = Float.NEGATIVE_INFINITY;
for (Node node : graph.getNodes()) {
NodeData nodeData = node.getNodeData();
minX = Math.min(minX, nodeData.x());
maxX = Math.max(maxX, nodeData.x());
minY = Math.min(minY, nodeData.y());
maxY = Math.max(maxY, nodeData.y());
minZ = Math.min(minZ, nodeData.z());
maxZ = Math.max(maxZ, nodeData.z());
minSize = Math.min(minSize, nodeData.getSize());
maxSize = Math.max(maxSize, nodeData.getSize());
}
}
private void writeColumns(Clusterer clusterer) {
Cluster[] clusters = clusterer.getClusters();
if (clusters != null && clusters.length > 0) {
ClustererBuilder builder = getBuilder(clusterer);
AttributeModel am = Lookup.getDefault().lookup(AttributeController.class).getModel();
String id = "clustering_" + builder.getName();
String title = "Clustering (" + builder.getName() + ")";
AttributeColumn col = am.getNodeTable().getColumn(id);
if (col == null) {
col =
am.getNodeTable()
.addColumn(id, title, AttributeType.INT, AttributeOrigin.COMPUTED, null);
StatusDisplayer.getDefault()
.setStatusText("A new column \"" + title + "\" has been created");
}
for (int i = 0; i < clusters.length; i++) {
Integer clusterId = new Integer(i);
for (Node n : clusters[i].getNodes()) {
n.getNodeData().getAttributes().setValue(col.getIndex(), clusterId);
}
}
}
}
@Override
public void execute(GraphModel graphModel, AttributeModel attributeModel) {
// Graph graph = graphModel.getGraphVisible();
HierarchicalGraph graph = null;
// get visible graph
if (directed) {
graph = graphModel.getHierarchicalDirectedGraphVisible();
} else {
graph = graphModel.getHierarchicalUndirectedGraphVisible();
}
// lock graph
graph.readLock();
try {
Progress.start(progressTicket, graph.getNodeCount());
// all coefficients
nodeCoefficients = new double[graph.getNodeCount()];
// attribute column
AttributeTable nodeTable = attributeModel.getNodeTable();
AttributeColumn clusteringColumn = nodeTable.getColumn("newClusteringCoefficient");
if (clusteringColumn == null) {
clusteringColumn =
nodeTable.addColumn(
"newClusteringCoefficient",
"Local Clustering Coefficient",
AttributeType.DOUBLE,
AttributeOrigin.COMPUTED,
0.0);
}
int i = 0;
// for each node
for (Node e : graph.getNodes()) {
// compute coefficient
double coeficient = 0.0;
double denominator = (graph.getDegree(e) * (graph.getDegree(e) - 1));
if (!directed) {
denominator /= 2;
}
double numerator = 0.0;
// get neighbors as list
List<Node> n2 = Arrays.asList(graph.getNeighbors(e).toArray());
List<Node> neighbors2 = new ArrayList<Node>(n2);
for (Node neighbor1 : graph.getNeighbors(e)) {
neighbors2.remove(neighbor1);
// count edges betwwen neighbors
for (Node neighbor2 : neighbors2) {
if (graph.getEdge(neighbor1, neighbor2) != null
|| graph.getEdge(neighbor2, neighbor1) != null) {
numerator++;
}
}
}
// compute coefficient
if (denominator > 0) {
coeficient = numerator / denominator;
} else {
coeficient = 0.0;
}
averageCoefficient += coeficient;
nodeCoefficients[i] = coeficient;
i++;
// set attribute
AttributeRow row = (AttributeRow) e.getNodeData().getAttributes();
row.setValue(clusteringColumn, coeficient);
Progress.progress(progressTicket);
if (cancel) {
break;
}
}
if (graph.getNodeCount() > 0) {
averageCoefficient = averageCoefficient / graph.getNodeCount();
}
graph.readUnlockAll();
} catch (Exception e) {
e.printStackTrace();
// Unlock graph
graph.readUnlockAll();
}
}
@Test
public void testPNG() {
try {
// Init a project - and therefore a workspace
ProjectController pc = Lookup.getDefault().lookup(ProjectController.class);
pc.newProject();
Workspace workspace = pc.getCurrentWorkspace();
// Append container to graph structure
String sample = "/org/gephi/desktop/welcome/samples/Les Miserables.gexf";
final InputStream stream = WelcomeTopComponent.class.getResourceAsStream(sample);
ImportController importController = Lookup.getDefault().lookup(ImportController.class);
FileImporter fileImporter = importController.getFileImporter(".gexf");
Container container = importController.importFile(stream, fileImporter);
importController.process(container, new DefaultProcessor(), workspace);
// Add self loop
GraphController graphController = Lookup.getDefault().lookup(GraphController.class);
Graph graph = graphController.getModel().getGraph();
Node node = graph.getNode(12);
System.out.println("Self loop " + node.getNodeData().getLabel());
graph.addEdge(graphController.getModel().factory().newEdge(node, node, 31, true));
// Set label edges
for (Edge edge : graphController.getModel().getGraph().getEdges()) {
edge.getEdgeData().setLabel("Label test");
}
// svg document
// attribute ???
AttributeController attributeController =
Lookup.getDefault().lookup(AttributeController.class);
AttributeModel attributeModel = null;
// preview
PreviewController previewController = Lookup.getDefault().lookup(PreviewController.class);
PreviewModel previewModel = previewController.getModel(workspace);
PreviewProperties previewProperties = previewModel.getProperties();
previewController.refreshPreview(workspace);
previewModel.getProperties().putValue("width", 1000);
previewModel.getProperties().putValue("height", 1000);
ProcessingTarget target =
(ProcessingTarget)
previewController.getRenderTarget(RenderTarget.PROCESSING_TARGET, workspace);
previewProperties.putValue(LegendModel.LEGEND_PROPERTIES, new LegendModel(workspace));
LegendModel legendManager = previewProperties.getValue(LegendModel.LEGEND_PROPERTIES);
Integer itemIndex = legendManager.getCurrentIndex();
// creating item
Item item = addGroupsItem(itemIndex, graph, attributeModel);
// Item item = addTextItem(itemIndex, graph, attributeModel);
// add item
LegendController.getInstance().addItemToLegendModel(workspace, item);
// render
previewController.refreshPreview(workspace);
previewController.render(target);
File fileToSave = new File("/Volumes/edubecks/edubecks/Untitled.png");
OutputStream fos = new FileOutputStream(fileToSave);
Writer writer = new OutputStreamWriter(fos, "UTF-8");
// // saving
// int width = 1000;
// int height = 1000;
// PGraphicsJava2D pg2 = (PGraphicsJava2D) target.getGraphics();
// BufferedImage img = new BufferedImage(width, height,
// BufferedImage.TYPE_INT_ARGB);
//
// System.out.println("@Var: pg2.pixels: "+pg2.pixels);
// img.setRGB(0, 0, width, height, pg2.pixels, 0, width);
// ImageIO.write(img, "png", fileToSave);
// stream.close();
PNGExporter pngExporter = new PNGExporter();
// pngExporter.setHeight(2000);
// pngExporter.setWidth(2000);
pngExporter.setWorkspace(workspace);
pngExporter.setOutputStream(fos);
pngExporter.execute();
} catch (Exception e) {
Exceptions.printStackTrace(e);
}
}
private void doPoetGraph(String path, String poet) {
System.out.println(poet);
ProjectController pc = Lookup.getDefault().lookup(ProjectController.class);
pc.newProject();
Workspace workspace = pc.getCurrentWorkspace();
GraphModel graphModel = Lookup.getDefault().lookup(GraphController.class).getModel();
UndirectedGraph directedGraph = graphModel.getUndirectedGraph();
ExportController ec = Lookup.getDefault().lookup(ExportController.class);
ArrayList<String> queue = new ArrayList<String>();
ArrayList<Integer> depthqueue = new ArrayList<Integer>();
queue.add(poet);
depthqueue.add(0);
int depth = 0;
int nodecount = 0;
while (queue.size() != 0 && depth < 3 && nodecount < 20) {
String name = queue.remove(0);
depth = depthqueue.remove(0);
Node n = directedGraph.getNode(name);
if (n == null) {
n = graphModel.factory().newNode(name);
n.getNodeData().setLabel(name);
directedGraph.addNode(n);
nodecount++;
}
Iterator<String> it = edges.get(poet).keySet().iterator();
while (it.hasNext()) {
String to = it.next();
Node slave = directedGraph.getNode(to);
if (slave == null) {
slave = graphModel.factory().newNode(to);
slave.getNodeData().setLabel(to);
directedGraph.addNode(slave);
}
Edge e = graphModel.factory().newEdge(n, slave, edges.get(poet).get(to) * 15, false);
directedGraph.addEdge(e);
queue.add(to);
depthqueue.add(depth + 1);
}
}
// Preview
PreviewModel previewModel = Lookup.getDefault().lookup(PreviewController.class).getModel();
previewModel.getProperties().putValue(PreviewProperty.SHOW_NODE_LABELS, Boolean.TRUE);
previewModel.getProperties().putValue(PreviewProperty.EDGE_COLOR, new EdgeColor(Color.BLUE));
previewModel.getProperties().putValue(PreviewProperty.EDGE_THICKNESS, new Float(0.005f));
previewModel
.getProperties()
.putValue(PreviewProperty.NODE_LABEL_COLOR, new DependantOriginalColor(Color.RED));
previewModel
.getProperties()
.putValue(
PreviewProperty.NODE_LABEL_FONT,
previewModel
.getProperties()
.getFontValue(PreviewProperty.NODE_LABEL_FONT)
.deriveFont(12));
YifanHuLayout layout = new YifanHuLayout(null, new StepDisplacement(1f));
layout.setGraphModel(graphModel);
layout.resetPropertiesValues();
layout.setOptimalDistance(120f);
layout.initAlgo();
for (int i = 0; i < 100 && layout.canAlgo(); i++) {
layout.goAlgo();
}
try {
ec.exportFile(new File(path + poet + ".svg"));
} catch (IOException ex) {
ex.printStackTrace();
return;
}
}