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 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();
}
public Graph filter(Graph[] graphs) {
HierarchicalGraph minHGraph = (HierarchicalGraph) graphs[0];
int minElements = Integer.MAX_VALUE;
for (int i = 0; i < graphs.length; i++) {
int count = ((HierarchicalGraph) graphs[i]).getNodeCount();
if (count < minElements) {
minHGraph = (HierarchicalGraph) graphs[i];
minElements = count;
}
}
for (Node n : minHGraph.getNodes().toArray()) {
for (int i = 0; i < graphs.length; i++) {
if ((HierarchicalGraph) graphs[i] != minHGraph) {
if (!((HierarchicalGraph) graphs[i]).contains(n)) {
minHGraph.removeNode(n);
break;
}
}
}
}
for (Edge e : minHGraph.getEdges().toArray()) {
for (int i = 0; i < graphs.length; i++) {
if ((HierarchicalGraph) graphs[i] != minHGraph) {
if (!((HierarchicalGraph) graphs[i]).contains(e)) {
minHGraph.removeEdge(e);
break;
}
}
}
}
return minHGraph;
}
public void updatePotatoes(HierarchicalGraph graph) {
ModelClass potatoClass = engine.getModelClasses()[AbstractEngine.CLASS_POTATO];
if (potatoClass.isEnabled()) {
Modeler potInit = engine.getModelClasses()[AbstractEngine.CLASS_POTATO].getCurrentModeler();
List<ModelImpl> hulls = new ArrayList<ModelImpl>();
Node[] nodes = graph.getNodes().toArray();
for (Node n : nodes) {
Node parent = graph.getParent(n);
if (parent != null) {
Group group = (Group) parent;
Model hullModel = group.getGroupData().getHullModel();
if (hullModel != null && hullModel.isCacheMatching(cacheMarker)) {
ConvexHull hull = (ConvexHull) hullModel.getObj();
hull.addNode(n);
hull.setModel(hullModel);
} else if (hullModel != null) {
// Its not the first time the hull exist
ConvexHullModel model = (ConvexHullModel) hullModel;
model.setScale(1f);
hullModel.setCacheMarker(cacheMarker);
hulls.add((ModelImpl) hullModel);
} else {
ConvexHull ch = new ConvexHull();
ch.setMetaNode(parent);
ch.addNode(n);
ModelImpl obj = potInit.initModel(ch);
group.getGroupData().setHullModel(obj);
obj.setCacheMarker(cacheMarker);
hulls.add(obj);
}
}
}
for (ModelImpl im : hulls) {
ConvexHull hull = (ConvexHull) im.getObj();
hull.recompute();
engine.addObject(AbstractEngine.CLASS_POTATO, im);
}
}
}
@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();
}
}
public Graph filter(Graph graph, Filter[] filters) {
HierarchicalGraph hgraph = (HierarchicalGraph) graph;
List<NodeFilter> nodeFilters = new ArrayList<NodeFilter>();
List<EdgeFilter> edgeFilters = new ArrayList<EdgeFilter>();
for (Filter f : filters) {
if (f instanceof NodeFilter) {
nodeFilters.add((NodeFilter) f);
} else if (f instanceof EdgeFilter) {
edgeFilters.add((EdgeFilter) f);
}
}
if (nodeFilters.size() > 0) {
for (Iterator<NodeFilter> itr = nodeFilters.iterator(); itr.hasNext(); ) {
NodeFilter nf = itr.next();
if (!nf.init(hgraph)) {
itr.remove();
}
}
List<Node> nodesToRemove = new ArrayList<Node>();
for (Node n : hgraph.getNodes()) {
for (NodeFilter nf : nodeFilters) {
if (!nf.evaluate(hgraph, n)) {
nodesToRemove.add(n);
break;
}
}
}
for (Node n : nodesToRemove) {
hgraph.removeNode(n);
}
for (NodeFilter nf : nodeFilters) {
nf.finish();
}
}
if (edgeFilters.size() > 0) {
for (Iterator<EdgeFilter> itr = edgeFilters.iterator(); itr.hasNext(); ) {
EdgeFilter ef = itr.next();
if (!ef.init(hgraph)) {
itr.remove();
}
}
List<Edge> edgesToRemove = new ArrayList<Edge>();
for (Edge e : hgraph.getEdges()) {
for (EdgeFilter ef : edgeFilters) {
if (!ef.evaluate(hgraph, e)) {
edgesToRemove.add(e);
break;
}
}
}
for (Edge e : edgesToRemove) {
hgraph.removeEdge(e);
}
for (EdgeFilter ef : edgeFilters) {
ef.finish();
}
}
return hgraph;
}