package org.openslx.graph;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.Stroke;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.commons.math3.util.FastMath;
import com.google.gson.annotations.Expose;
/**
* The Graph stores the Nodes and Edges, and InferenceHeurisics to allow
* the structure of the graph to be modified.
*/
public class Graph implements java.io.Serializable
{
private static final long serialVersionUID = 5488288903546706793L;
private String _label;
private String _caption = "servers are grey, clients are blue, sugar is sweet, and so are you";
private Map<Node, Node> _nodes = new HashMap<>();
private Map<Edge, Edge> _edges = new HashMap<>();
@Expose
private Collection<Node> nodes = _nodes.values();
@Expose
private Collection<Edge> edges = _edges.values();
private double minX = Double.POSITIVE_INFINITY;
private double maxX = Double.NEGATIVE_INFINITY;
private double minY = Double.POSITIVE_INFINITY;
private double maxY = Double.NEGATIVE_INFINITY;
private double maxWeight = 0;
private int _frameCount = 0;
private static final Color COLOR_BG = new Color( 250, 250, 255 );
private static final Color COLOR_TITLE = new Color( 200, 200, 255 );
private static final Color COLOR_LABEL = new Color( 0, 0, 20 );
private static final Color COLOR_LABEL_SHADOW = new Color( 220, 220, 220 );
private static final Color COLOR_TITLE2 = new Color( 190, 190, 210 );
private static final Color COLOR_EDGE = new Color( 100, 100, 255 );
private static final int IMG_X = 1280;
private static final int IMG_Y = 1024;
private final Graphics2D graphicsContext;
private final PngRenderer renderer;
public Graph( String label )
{
_label = label;
BufferedImage targetImage = new BufferedImage( IMG_X, IMG_Y, BufferedImage.TYPE_INT_ARGB );
graphicsContext = targetImage.createGraphics();
graphicsContext.setRenderingHint( RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON );
renderer = new PngRenderer( targetImage );
}
// Add a Node to the Graph.
public void addNode( Node node )
{
// Only add the Node to the HashMap if it's not already in there.
if ( _nodes.containsKey( node ) )
return;
_nodes.put( node, node );
}
// Add an Edge to the Graph. Increment the weighting if it already exists.
public void setEdge( Node source, Node target, double weight )
{
// Do not add self-edges or weights that are not positive.
if ( source.equals( target ) || weight <= 0 ) {
return;
}
addNode( source );
addNode( target );
// Add the Edge to the HashMap, or find the existing entry.
Edge edge = _edges.get( new Edge( source, target ) );
if ( edge == null ) {
source = _nodes.get( source );
target = _nodes.get( target );
edge = new Edge( source, target );
_edges.put( edge, edge );
}
// Set the edge weight.
edge.setWeight( weight );
}
// Remove a Node from the Graph, along with all of its emanating Edges.
public boolean removeNode( Node node )
{
if ( !_nodes.containsKey( node ) )
return false;
// Remove the Node from the HashMap.
_nodes.remove( node );
// Remove all Edges that connect to the removed Node.
Iterator<Edge> edgeIt = _edges.keySet().iterator();
while ( edgeIt.hasNext() ) {
Edge edge = edgeIt.next();
if ( edge.getSource().equals( node ) || edge.getTarget().equals( node ) ) {
edgeIt.remove();
}
}
return true;
}
// Return true if the Graph contains the Node.
// (This does not necessarily imply that the Node is visible).
public boolean contains( Node node )
{
return _nodes.containsKey( node );
}
// Return true if the Graph contains the Edge.
public boolean contains( Edge edge )
{
return _edges.containsKey( edge );
}
// Return the Graph's Node that has the same nick as the supplied Node.
public Node get( Node node )
{
return _nodes.get( node );
}
// Return the Graph's Edge that matched the supplied Edge.
public Edge get( Edge edge )
{
return _edges.get( edge );
}
public String toString()
{
return "Graph: " + _nodes.size() + " nodes and " + _edges.size() + " edges.";
}
public String toString2()
{
return "Nodes:\n" + _nodes + "\nEdges:\n" + _edges;
}
// Apply the temporal decay to the Graph.
public void decay()
{
for ( Iterator<Edge> it = _edges.values().iterator(); it.hasNext(); ) {
Edge edge = it.next();
edge.resetWeight();
if ( !edge.isAlive() ) {
it.remove();
}
}
List<Node> toRemove = null;
for ( Node node : _nodes.values() ) {
node.age();
if ( !node.isAlive() ) {
if ( toRemove == null ) {
toRemove = new ArrayList<>();
}
toRemove.add( node );
}
}
if ( toRemove != null ) {
for ( Node node : toRemove ) {
removeNode( node );
}
}
}
// Returns the set of all Nodes that have emanating Edges.
// This therefore returns all Nodes that will be visible in the drawing.
public Set<Node> getConnectedNodes()
{
Set<Node> connectedNodes = new HashSet<>();
for ( Edge edge : _edges.values() ) {
connectedNodes.add( edge.getSource() );
connectedNodes.add( edge.getTarget() );
}
return connectedNodes;
}
public Collection<Edge> getEdges()
{
return _edges.values();
}
// Limit movement values to stop nodes flying into oblivion.
private static final double MAX_MOVE = 0.75;
private static final double K = 2;
private static final double MOVEMENT_SLOWDOWN = 0.001;
// Applies the spring embedder.
private void doLayout( Set<Node> visibleNodes, int iterations )
{
// For performance, copy each set into an array.
Node[] nodes = visibleNodes.toArray( new Node[ visibleNodes.size() ] );
Edge[] edges = _edges.keySet().toArray( new Edge[ _edges.size() ] );
if ( nodes.length == 0 )
return;
// For each iteration...
for ( int it = 0; it < iterations; it++ ) {
// Calculate forces acting on nodes due to node-node repulsions...
for ( int a = 0; a < nodes.length; a++ ) {
final Node nodeA = nodes[a];
for ( int b = a + 1; b < nodes.length; b++ ) {
final Node nodeB = nodes[b];
double deltaX = nodeB.getX() - nodeA.getX();
double deltaY = nodeB.getY() - nodeA.getY();
final double maxDistance = ( nodeA.getDesiredDistance() * nodeB.getDesiredDistance() ) * 0.9;
double distanceSquared = deltaX * deltaX + deltaY * deltaY;
if ( distanceSquared > maxDistance * maxDistance )
continue;
if ( distanceSquared < 0.01 ) {
deltaX = Math.random() / 10 + 0.1;
deltaY = Math.random() / 10 + 0.1;
distanceSquared = deltaX * deltaX + deltaY * deltaY;
}
final double distance = FastMath.sqrt( distanceSquared );
final double repulsiveForce = ( K * maxDistance / distance ) * 2;
final double sumDesired = nodeA.getDesiredDistance() + nodeB.getDesiredDistance();
// A gets pushed away stronger if B has higher desired distance than A
final double rfA = repulsiveForce * ( nodeB.getDesiredDistance() / sumDesired );
// Vice versa for B
final double rfB = repulsiveForce * ( nodeA.getDesiredDistance() / sumDesired );
nodeB.addForceX( ( rfB * deltaX / distance ) );
nodeB.addForceY( ( rfB * deltaY / distance ) );
nodeA.addForceX( - ( rfA * deltaX / distance ) );
nodeA.addForceY( - ( rfA * deltaY / distance ) );
}
}
// Calculate forces acting on nodes due to edge attractions.
for ( int e = 0; e < edges.length; e++ ) {
final Edge edge = edges[e];
final Node nodeA = edge.getSource();
final Node nodeB = edge.getTarget();
final double minDistance = ( nodeA.getDesiredDistance() * nodeB.getDesiredDistance() ) * 1.1;
final double deltaX = nodeB.getX() - nodeA.getX();
final double deltaY = nodeB.getY() - nodeA.getY();
double distanceSquared = deltaX * deltaX + deltaY * deltaY;
if ( distanceSquared < minDistance * minDistance )
continue;
double distance = FastMath.sqrt( distanceSquared );
if ( distance > minDistance * 2 ) {
distance = minDistance * 2;
distanceSquared = distance * distance;
}
final double attractiveForce = ( distanceSquared / K ) * 2;
final double sumDesired = nodeA.getDesiredDistance() + nodeB.getDesiredDistance();
// A gets pulled towards B stronger if B has higher desired distance than A
final double afA = attractiveForce * ( nodeB.getDesiredDistance() / sumDesired );
// Vice versa for B
final double afB = attractiveForce * ( nodeA.getDesiredDistance() / sumDesired );
nodeB.addForceX( -afB * deltaX / distance );
nodeB.addForceY( -afB * deltaY / distance );
nodeA.addForceX( afA * deltaX / distance );
nodeA.addForceY( afA * deltaY / distance );
}
// Now move each node to its new location...
for ( int a = 0; a < nodes.length; a++ ) {
Node node = nodes[a];
// General weak attraction towards (0|0)
if ( node.getDesiredDistance() > 5 ) {
node.addForceX( -node.getX() / 500 );
node.addForceY( -node.getY() / 500 );
}
double xMovement = MOVEMENT_SLOWDOWN * node.getFX();
double yMovement = MOVEMENT_SLOWDOWN * node.getFY();
if ( xMovement > MAX_MOVE ) {
xMovement = MAX_MOVE;
}
else if ( xMovement < -MAX_MOVE ) {
xMovement = -MAX_MOVE;
}
if ( yMovement > MAX_MOVE ) {
yMovement = MAX_MOVE;
}
else if ( yMovement < -MAX_MOVE ) {
yMovement = -MAX_MOVE;
}
node.setX( node.getX() + xMovement );
node.setY( node.getY() + yMovement );
// Reset the forces
node.resetForce();
}
// Swap two random nodes if it results in less stress on them
Node a = nodes[(int) ( Math.random() * nodes.length )];
Node b = nodes[(int) ( Math.random() * nodes.length )];
if ( !a.equals( b ) ) {
double initialLen = getEdgeLenSum( edges, a, b );
a.swapPos( b );
double swappedLen = getEdgeLenSum( edges, a, b );
if ( swappedLen + 0.5 > initialLen ) {
a.swapPos( b ); // Isn't any better, swap back
}
}
}
}
private double getEdgeLenSum( Edge[] edges, Node a, Node b )
{
double result = 0;
for ( Edge edge : edges ) {
if ( edge.hasNode( a ) || edge.hasNode( b ) ) {
result += edge.getLengthSquared();
}
}
return result;
}
// Work out the drawing boundaries...
public void calcBounds( Set<Node> nodes )
{
minX = Double.POSITIVE_INFINITY;
maxX = Double.NEGATIVE_INFINITY;
minY = Double.POSITIVE_INFINITY;
maxY = Double.NEGATIVE_INFINITY;
maxWeight = 0;
for ( Node node : nodes ) {
if ( node.getX() > maxX ) {
maxX = node.getX();
}
if ( node.getX() < minX ) {
minX = node.getX();
}
if ( node.getY() > maxY ) {
maxY = node.getY();
}
if ( node.getY() < minY ) {
minY = node.getY();
}
}
// Increase size if too small.
final double minSize = 10;
if ( maxX - minX < minSize ) {
double midX = ( maxX + minX ) / 2;
minX = midX - ( minSize / 2 );
maxX = midX + ( minSize / 2 );
}
if ( maxY - minY < minSize ) {
double midY = ( maxY + minY ) / 2;
minY = midY - ( minSize / 2 );
maxY = midY + ( minSize / 2 );
}
// Work out the maximum weight.
for ( Edge edge : _edges.values() ) {
if ( edge.getWeight() > maxWeight ) {
maxWeight = edge.getWeight();
}
}
// Jibble the boundaries to maintain the aspect ratio.
double xyRatio = ( ( maxX - minX ) / ( maxY - minY ) ) / ( IMG_X / IMG_Y );
if ( xyRatio > 1 ) {
// diagram is wider than it is high.
double dy = maxY - minY;
dy = dy * xyRatio - dy;
minY = minY - dy / 2;
maxY = maxY + dy / 2;
}
else if ( xyRatio < 1 ) {
// Diagram is higher than it is wide.
double dx = maxX - minX;
dx = dx / xyRatio - dx;
minX = minX - dx / 2;
maxX = maxX + dx / 2;
}
}
private static final Font FONT_64 = new Font( "SansSerif", Font.BOLD, 64 );
private static final Font FONT_18 = new Font( "SansSerif", Font.BOLD, 18 );
private static final Font FONT_12 = new Font( "SansSerif", Font.PLAIN, 12 );
private static final Font FONT_10 = new Font( "SansSerif", Font.PLAIN, 10 );
private static final Stroke STROKE_2 = new BasicStroke( 2.0f );
public void drawImage( Set<Node> nodes, double edgeThreshold )
{
// Now actually draw the thing...
graphicsContext.setColor( COLOR_BG );
graphicsContext.fillRect( 0, 0, IMG_X, IMG_Y );
graphicsContext.setColor( COLOR_TITLE );
graphicsContext.setFont( FONT_64 );
graphicsContext.drawString( _label, 20, 80 );
graphicsContext.setColor( COLOR_TITLE2 );
graphicsContext.setFont( FONT_18 );
graphicsContext.drawString( _caption, 0, IMG_Y - 5 - 50 );
graphicsContext.setFont( FONT_12 );
graphicsContext.drawString( "This frame was drawn at " + new Date(), 0, IMG_Y - 5 );
// Draw all edges...
for ( Edge edge : _edges.values() ) {
if ( edge.getWeight() < edgeThreshold ) {
continue;
}
double weight = edge.getWeight();
Node nodeA = edge.getSource();
Node nodeB = edge.getTarget();
int x1 = toImageX( nodeA );
int y1 = toImageY( nodeA );
int x2 = toImageX( nodeB );
int y2 = toImageY( nodeB );
graphicsContext.setStroke( new BasicStroke( (float) ( FastMath.log( weight + 1 ) * 0.1 ) + 1 ) );
final int alpha = 102 + (int) ( 153 * weight / maxWeight );
graphicsContext.setColor( new Color( ( edge.getColor().getRGB() & 0xffffff ) | ( alpha << 24 ), true ) );
graphicsContext.drawLine( x1, y1, x2, y2 );
}
// Draw all nodes...
graphicsContext.setStroke( STROKE_2 );
graphicsContext.setFont( FONT_10 );
for ( Node node : nodes ) {
final int x = toImageX( node );
final int y = toImageY( node );
final int nodeRadius = node.getRadius();
graphicsContext.setColor( node.getColor() );
graphicsContext.fillOval( x - nodeRadius, y - nodeRadius, nodeRadius * 2, nodeRadius * 2 );
graphicsContext.setColor( COLOR_EDGE );
graphicsContext.drawOval( x - nodeRadius, y - nodeRadius, nodeRadius * 2, nodeRadius * 2 );
graphicsContext.setColor( COLOR_LABEL_SHADOW );
graphicsContext.drawString( node.toString(), x - ( node.toString().length() * 3 ) + 1, y - nodeRadius - 2 + 1 );
graphicsContext.setColor( COLOR_LABEL );
graphicsContext.drawString( node.toString(), x - ( node.toString().length() * 3 ), y - nodeRadius - 2 );
}
}
private int toImageX( Node node )
{
return (int) ( ( IMG_X - 50 ) * ( node.getX() - minX ) / ( maxX - minX ) ) + 25;
}
private int toImageY( Node node )
{
return (int) ( ( IMG_Y - 55 ) * ( node.getY() - minY ) / ( maxY - minY ) ) + 35;
}
public int getFrameCount()
{
return _frameCount;
}
public String getLabel()
{
return _label;
}
public void setCaption( String caption )
{
_caption = caption;
}
public byte[] makeNextImage()
{
_frameCount++;
Set<Node> nodes = getConnectedNodes();
doLayout( nodes, 200 );
calcBounds( nodes );
ByteArrayOutputStream baos = new ByteArrayOutputStream( 100000 );
try {
drawImage( nodes, 0.1 );
//ImageIO.write( targetImage, "png", baos );
renderer.render( baos );
writeGraph();
return baos.toByteArray();
} catch ( Exception e ) {
System.out.println( "PieSpy has gone wibbly: " + e );
e.printStackTrace();
}
return null;
}
// Serialize this Graph and write it to a File.
public void writeGraph()
{
/*
try {
String strippedChannel = _label.toLowerCase().substring( 1 );
File dir = new File( config.outputDirectory, strippedChannel );
File file = new File( dir, strippedChannel + "-restore.dat" );
ObjectOutputStream oos = new ObjectOutputStream( new FileOutputStream( file ) );
oos.writeObject( SocialNetworkBot.VERSION );
oos.writeObject( this );
oos.flush();
oos.close();
} catch ( Exception e ) {
// Do nothing?
}
*/
}
public Node getNode( String id )
{
return _nodes.get( new Node( id ) );
}
}
