Network Visualization

Newbie & Debugging Questions
#1

I am working on a Masters project that takes a network trace file, builds the nodes and connections and then shows in real time the packets being passed between the nodes. I have my first iteration completed using the Swing library but due to the large size of the networks I am running into performance issues. I started trying to look for a hardware accelerated option and I came up with JOGL and LWJGL. Not being a graphics programmer I am hoping for some objective advice… Which of the two would be easier for me to learn for my network visualizer? Keep in mind I have not taken any classes, I will probably be using tutorials to learn everything (unless you can suggest a good book). I got the JOGL demo from wikipedia working and I don’t have any complaints but it seems JOGL is a little light on the tutorial side of things. Anyways, I am not trying to start a flame war please I just need some advice. Thanks in advance.

EDIT: Right now I actually do not need 3-D functionality but in the future I might build it in since I am modeling wireless ad-hoc networks and the wireless nodes do move in the simlulation.

#2

You might want to check out Processing (http://processing.org), which has pretty easy JOGL integration (at least within its own IDE, you just write "size(w, h, OPENGL); " and then import the OpenGL library from the drop down, all the other crap is handled for you - it’s more complicated from Eclipse, but no more complicated than getting your own JOGL project to work without build/link errors) and is often used for data visualization. There are a lot of tutorials on how to use it, and within the IDE you can be up and running with a JOGL “sketch” within a minute or two and start running through all the built in examples, which show you how to use most of the drawing functions.

Using “real” JOGL or LWJGL is great if you actually need to, and for games it is pretty crucial, but if graphics aren’t a primary concern then there’s no point in lingering too much on the topic. If you go down that route, you’re going to find that every “simple” thing that you would think should take a single function call is, in fact, its own topic, with associated setup, state handling, and boilerplate code to actually do it. Nothing against either library, btw, it’s just that OpenGL is a pretty low level graphics API, not a convenient wrapper to make things easy to do, and the “cut-and-paste from Nehe” approach gets very cumbersome when you need more than a handful of features, and it takes a lot of experience to design your own wrapper for all that stuff in the right way.

If Processing can’t cut it performance-wise, you may want to try Slick if you’re in 2d, I’ve found that Slick can handle a lot more graphics output than Processing can (I suspect mainly because Processing does geometric transformations in the Java code rather than on the hardware). But I would definitely give Processing a look, the whole thing is specifically designed for easy data visualization (Ben Fry is a huge data junkie, and it’s clear in the API design).

#3

Also take a look at Prefuse (http://www.prefuse.org/), which is a information visualization framework in java.

#4

Wow, that’s got some very cool stuff. A lot higher level than Processing, which can be a very good thing since there’s so much built in functionality, though it also means more to learn. I’ll definitely be checking that out.

On the FAQ page there (http://prefuse.org/doc/faq/) there’s a list of other options to consider, as well (there are links if you go to that page):

* Piccolo - A Java toolkit for structured 2D graphics using a scenegraph abstraction.
* Processing - A graphics library and IDE serving as an artist's digital sketchbook.
* The Visualization Toolkit (VTK) - A 3D graphics and visualization toolkit.
* JUNG - A Java graph processing and visualization library.
* The InfoVis Toolkit - A Java toolkit supporting a number of visualization techniques.
* Improvise - An application for end-user authoring of interactive visualizations.

Might be worth looking through…

#5

Wow awesome resources there guys, thanks for the help. I will let you know what I go with.

#6

For what it’s worth, I found prefuse to have a very steep learning curve. Once you are inside of it, you can do some amazing stuff, but it’s not for the faint of heart, or for someone one a tight timeline. Processing is much easier, but it’s a little awkward: it’s a programming language that compiles to Java bytecode, but it’s also a library that can be called directly from regular Java applications. The procedural design of it does not jive as well with an OO application as prefuse does, due to prefuse’s patterns-oriented architecture (which is both its strength and its weakness).

If all you need to do is animate some blobs from A to B and you don’t already know OpenGL, my recommendation is Slick. It will essentially require to write your application as a “game”, with a main game loop, update/render cycle, etc., but that works well for visualization applications. The Slick website has great tutorials to get you started doing the fundamental things you’ll want: loading images, moving them around, mouse interaction, etc.