**Share the article!**

Just as I did the last list “Open Source Structured Graphics Libraries Written in Java” I realized that I needed an entirely new category. Well here’s that category, network or graph visualization written in open source Java. It’s got some pretty stunning visuals so I recommend that everyone eyeball them.

- GINY – There is currently no good, open-source Java graphing library. GINY seeks to fill this need. (That’s a pretty bold statement!) The visual side of GINY is implemented making extensive use of Piccolo. Algorithms include All Pairs Shortest Path, Spring Embedded Layout and Sugiyam Hierarchical Layout. Extremely ambitious embedded in a real application.
- JUNG – JUNG xe2x80x94 the Java Universal Network/Graph Framework–is a software library that provides a common and extendible language for the modeling, analysis, and visualization of data that can be represented as a graph or network. The JUNG architecture is designed to support a variety of representations of entities and their relations, such as directed and undirected graphs, multi-modal graphs, graphs with parallel edges, and hypergraphs. It provides a mechanism for annotating graphs, entities, and relations with metadata. The current distribution of JUNG includes implementations of a number of algorithms from graph theory, data mining, and social network analysis, such as routines for clustering, decomposition, optimization, random graph generation, statistical analysis, and calculation of network distances, flows, and importance measures (centrality, PageRank, HITS, etc.). Comprehensive, everything but the kitchen sink!
- HyperGraph – Handle hyperbolic space from a purely mathematical point of view

provide a Swing panel that shows a view on the hyperbolic plane. Whether the plane is shown in the Poncare model, half plane model or Klein model should be left to the user.

handle graphs of arbitrary structure and size; of course some basic algorithms, input/output classes etc.- JDigraph – JDigraph is a Java library for representing and working with directed graphs and paths. The API is patterned after the Java collections API.
- WilmaScope – WilmaScope is a Java3D application which creates real time 3d animations of dynamic graph structures. Currently supported features include:

Basic graph components (nodes & edges),

Text labels,

Translucent clusters of nodes, which may be collapsed to elide the contents and

Global and cluster-oriented force directed node layout

Force models including Edges as springs (with adjustable natural lengths), repulsion between nodes, long-range attraction to the origin, “field” orientation for directed edges and a planar force to squash graphs onto z=0. Visualizations with an additional dimension!- JGraphT – JGraphT supports various types of graphs including: directed and undirected graphs,

graphs with weighted / unweighted / labeled or any user-defined edges,

various edge multiplicity options, including: simple-graphs, multigraphs, pseudographs,

unmodifiable graphs – allow modules to provide “read-only” access to internal graphs,

listenable graphs – allow external listeners to track modification events,

subgraphs graphs that are auto-updating subgraph views on other graphs and

all compositions of mentioned graphs. Powerful, but simple.- TouchGraph – TouchGraph provides a hands-on way to visualize networks of interrelated information. Networks are rendered as interactive graphs, which lend themselves to a variety of transformations. By engaging their visual image, a user is able to navigate through large networks, and to explore different ways of arranging the network’s components on screen. Extremely cool google and amazon apps!
- GVF – The Graph Visualization Framework is a set of Java 2 packages that can serve as a foundation for applications that either manipulate graph structures or visualize them. The libraries implement several basic modules for input, graph management, property management, layout, and rendering. Layouts include Reingold-Tilford (hierachical – adapted for DAG’s), Fruchterman-Reingold (force-directed), Radial, Ring, Barycentric, Random. Add your own Pluggable layouts, metrics, clusterings, coloring. Reads GML, GraphXML, and CNS (Newick Format). Focus+context “fish-eye” interaction. Tounge tied!
- JGraphEd – JGraphEd features: Interactive graph creation (nodes, edges [directed, curved]),

Planarity Test and Planar Embedding [O(n) using PQ-Tree],

Biconnected Component finding & display [O(n) (n nodes, m edges)],

St Numbering & display [O(n)],

Make Biconnected planar operation [O(n)],

Make Maximal planar operation (triangulate) [O(n)],

Canonical Ordering of a maximal planar graph [O(n)],

Normal Labeling of a maximal planar graph [O(n)],

Schnyder Straight Line Grid Embedding (n-2 x n-2 grid] of planar graphs [O(n)],

Minimum Spanning tree display [O(mlogn)] and

Dijkstra Shortest Path display [O(mlogn)].

Several reusable data structures such as: The PQ-Tree data structure (Booth and Luekr),

The extended PQ-Tree data structure with direction nodes (Chiba and Nishizeki),A nodeSplitTree data structure for node searching (similar to a KD-Tree),

Various primitive data structures (Binary Heap, Doubly Linked List, FIFO Queue) and

The Half-Edge data structure (integrated with the Node and Edge objects). Impressive!- VGJ – Visualizing Graphs with Java (VGJ) is a tool for graph drawing and graph layout. VGJ has two major components: the graph editor and the layout algorithms. Layout algorithms are being developed and implemented to layout different categories of graphs such as trees, planar graphs, directed and undirected graphs, and series-parallel graphs. For the directed graphs, the drawing method uses a unique graph-grammar decomposition to identify intrinsic substructures (clans) in the graph. The method provides for a two-dimensional analysis of the graph while the typical approach to drawing digraphs uses the single dimension, level, to arrange the nodes.
- Zoomgraph – Visualizing Zoomable Data Driven Graphs. A zoomable interface to large graphs allowing for the visualization of graphs and networks on an infinite plane with infinite (smooth) zoom. A database driven system that allows nodes and edges to include attributes beyond basic display features (we support continuous, categorical, and binary attributes). From HP Labs so it must be decent!
- Walrus – Walrus is a tool for interactively visualizing large directed graphs in three-dimensional space. By employing 3D hyperbolic geometry to display graphs under a fisheye-like distortion, it provides a display that simultaneously shows local detail and the global context. Source available only to CAIDA members.
- Prefuse – Prefuse is a user interface toolkit for building highly interactive visualizations of structured and unstructured data. This includes any form of data that can be represented as a set of entities (or nodes) possibly connected by any number of relations (or edges). Examples of data supported by prefuse include hierarchies (organization charts, taxonomies, file systems), networks (computer networks, social networks, web site linkage) and even non-connected collections of data (timelines, scatterplots).
- ZVTM – Zoomable User Interface (ZUI) toolkit features a graphical object model that makes the task of creating, modifying and animating graphical entities easier, allows the definition of custom shapes. ZVTM also features smooth zooming capabilities (2.5D/zoomable user interface), multiple independent layers inside a single viewport, multi-threaded views, and support for exporting SVG documents.
- InfoVis Toolkit – The main characteristics of the InfoVis Toolkit are unified data structure, small memory footprint, unified set of interactive components, uses acelerated graphics based on Agile2D and extensible.
- InfoVis Cyberinfrastructure – The Information Visualization Cyberinfrastructure (IVC) is a platform-independent software framework developed in Java that allows diverse data modeling, analysis and visualization algorithms to be plugged-in and run as independent software components. While the algorithms might be developed by different researchers and implemented in different programming languages (e.g., Java, Perl, C, C++) using different graphics, math or other packages the IVC framework facilitates the seamless integration of those algorithms into a unified software package.
- Large Graph Layout – LGL is a compendium of applications for making the visualization of large networks and trees tractable. LGL was specifically motivated by the need to make the visualization and exploration of large biological networks more accessible.
- NV2D – NV2D is a graph visualization and layout tool written in Java that can run either as a standalone application or an applet embedded in a web browser. NV2D is a module of the NetVis project and the feature set emphasizes social network analysis.
- GUESS – GUESS is an exploratory data analysis and visualization tool for graphs and networks. The system contains a domain-specific embedded language called Gython (an extension of Python, or more specifically Jython) which supports the operators and syntactic sugar necessary for working on graph structures in an intuitive manner. An interactive interpreter binds the text that you type in the interpreter to the objects being visualized for more useful integration. GUESS also offers a visualization front end that supports the export of static images and dynamic movies.
- Otter – Otter is a tool used for visualizing arbitrary network data that can be expressed as a set of nodes, links or paths. Otter was developed to handle visualization tasks for a wide variety of Internet data, including data sets on topology, workload, performance, and routing.
- Gravisto – Gravisto is an editor for graphs and a toolkit for implementing graph visualization algorithms.
- Linguine Maps – Linguine Maps conducts programmatic visualization of various text files, generating from them easy-to-understand entity-relation diagrams. With a diagram it will take you and your team minutes now, instead of perhaps hours, to get familiar with new schema, object-relational mappings, or DTDs.
- Rox Graph Theory Framework – Rox its an open source framework for building Graph-based applications. It has been built essentially for academic problems like graph algorithm execution and theorem proofs. This project has two main cores: The Graph API, that provides the ability to work with graphs without a GUI and an Eclipse RCP that provides the ability to edit graphs and execute graph algorithms.
- JIGGLE – Solving the graph visualization problem involves both choosing a physical model and then using numerical optimization to simulate the physical system. JIGGLE improves the speed, drawing quality and flexibility using known techniques from many-body work in astrophysics, numerical optimization, heuristics and separation of concerns.
- Zest – Zest: The Eclipse Visualization Toolkit, is a set of visualization components built for Eclipse. Zest is a component of the Mylar project that can be used independently of the Mylar IDE support. Zest has been modeled after JFace, and all the Zest views conform to the same standards and conventions as existing Eclipse views. This means that the providers, actions and listeners used within existing applications can be leveraged within Zest. The Zest project also contains a graph layout package which can be used independently.
- Relo – Relo helps users explore and understand portions of large information spaces. It demonstrates the power of a number of ideas including: Relationship based approach: When the amount of information that needs to be understood gets large, then available relationships in the information get important. Not showing everything: As simple as it might sound: a core principle of Relo is to show the bare minimum amount of information, to minimize cognitive overhead.
- SoNIA – SoNIA is a package for visualizing dynamic or longitudinal “network” data. What is meant here by dynamic is that in addition to information about the relations between various entities (actors, nodes) there is also information about the time when these relations occur. SoNIA is designed to read-in dynamic network information from various formats, aid the user in constructing “meaningful” layouts, and export the resulting images or “movies” of the network, along with information about the techniques and parameter settings used to construct the layouts, and some form of statistic indicating the “accuracy” or degree of distortion present in the layout. SoNIA can be used as a platform for the development, testing, and comparison of various static and dynamic layout techniques.

If you know anything that I may have missed, please let me know!

**Share the article!**