Dynamic graph visualisation using JLink/Java and GraphStream

Nice answer by Mohsen, +1. I am continually impressed by the quality of the J/Link and .NET/Link expertise on this site. I have a couple remarks and then an example program.

The question asked about some general tips for getting started with J/Link. This GraphStream library provides a perfect example for the typical workflow of a J/Link project. The following are exactly the steps I went through when tinkering with this, and I'm sure Mohsen did as well.

• Download the library materials. Generally this will be one or more .jar files
• Make sure J/Link can find the jar files, by calling AddToClassPath
• Locate the javadocs for the library. Keep these open as a handy reference
• Skim the documentation, looking for any Getting Started/Tutorial type of information

Those steps might seem obvious, and could hardly be considered "advice", but the key point is that you are looking for a trivial example Java program. That is always the starting point. Once you find a small bit of sample code, you can translate it directly into Mathematica. Mohsen's first few lines of code, ending in g@display[], are right out of the "Getting Started" tutorial for GraphStream, literally the first lines of Java code they demonstrate. They translate directly into Mathematica almost trivially, as Mohsen describes (and the J/Link docs do, in more detail). Within a few minutes you have a Java window on your screen with a graph in it. This is an incredibly empowering feeling, and from there you can delve deeper into what the library provides. To do fancy things you will probably need to learn some subtleties of J/Link, and some familiarity with Java is extremely useful, but once you have something basic working, you can build from there.

I have tinkered with many Java libraries using J/Link, and I almost always have something running within a few minutes. Although I know J/Link very well, it usually takes only the most basic J/Link knowledge to get that far.

I strongly recommend not using ReinstallJava[ClassPath -> ...] for making Java libraries available to J/Link. Calling ReinstallJava is a destructive operation that you should only call if you absolutely need to. Any other Mathematica components or packages that are using J/Link might have some state wiped out if you restart Java. Instead, call AddToClassPath, which is exactly what you did in your question. What is particularly convenient about AddToClassPath is that you can give the directory in which a set of jar files reside, and all the jar files will be added.

Here is a sample program that uses GraphStream to dynamically render the sample graph. It also displays the output of Mathematica's GraphPlot for comparison.

Needs["JLink`"];
InstallJava[];
AddToClassPath["dir/with/graphstream/jar/files"];

(* We only ever need the node names as strings, so convert them ahead of time *)
graphData = dynamicGraph /. {a_Integer, b_Integer, c_, d_} :> {ToString[a], ToString[b], c, d};

graph = JavaNew["org.graphstream.graph.implementations.SingleGraph", "StackExchange"];
viewer = graph@display[];

(* We need this only for computing the coordinates of the middle of the image.*)
ggraph = viewer@getGraphicGraph[];

(* This makes the window go away when its close box is clicked. *)
LoadJavaClass["org.graphstream.ui.swingViewer.Viewer$CloseFramePolicy"];
    viewer@setCloseFramePolicy[Viewer$CloseFramePolicy`HIDEUONLY];

graph@setStrict[False];
nodes = {};
edges = {};

Manipulate[
    previousNodes = nodes;
    previousEdges = edges;

    edges = Select[graphData, #[[3]] <= t <= #[[4]]&][[All, 1;;2]];
    nodes = Union @ Flatten @ edges;

    losingNodes = Complement[previousNodes, nodes];
    addingNodes = Complement[nodes, previousNodes];
    losingEdges = Complement[previousEdges, edges];
    addingEdges = Complement[edges, previousEdges];

    (* We will create a lot of temporary Java objects, so use JavaBlock to ensure they  get cleaned up. *)
    JavaBlock[
        Function[nodeName,
            node = graph@addNode[nodeName];
            (* This whole bit is just to add new points near the middle of the image,
               otherwise you get ugly initial edges drawn to the edge of the image.
            *)
            If[Length[nodes] > 2,
                min = ggraph@getMinPos[];
                max = ggraph@getMaxPos[];
                middlex = Round@Mean[{min@x, max@x}];
                middley = Round@Mean[{min@y, max@y}];
                node@setAttribute["xyz", {MakeJavaObject[middlex], MakeJavaObject[middley], MakeJavaObject[0]}]
            ];
            node@addAttribute["ui.style", {MakeJavaObject["text-size: 14;"]}];
            node@addAttribute["ui.label", {MakeJavaObject[nodeName]}]
        ] /@ addingNodes;
        graph@removeNode[#]& /@ losingNodes;

        Function[{startNode, endNode},
            graph@addEdge[startNode <> endNode, startNode, endNode]
        ] @@@ addingEdges;

        Function[{startNode, endNode},
            graph@removeEdge[startNode <> endNode]
        ] @@@ losingEdges
    ];

    (* GraphPlot's display for comparison. *)
    GraphPlot[#1->#2& @@@ Select[dynamicGraph, #[[3]] <= t <= #[[4]]&], VertexRenderingFunction -> (Text[#2, #1]&)]
    ,
    {t, 0, 31, 1},
    TrackedSymbols -> {t}
]

You could do much, much more with this, of course. GraphStream has many controls for styling and behavior.