My name is Taras Klaskovsky and during this Summer Of Code I have implemented the Force Directed Edge Bundling algorithm.

Force Directed Edge Bundling (FDEB) is an edge layout algorithm. Gephi already has node layouts, which are placing the nodes (usually using force-directed algorithms). FDEB helps to further improve graph visualization by changing shapes and colors of the edges to merge them in bundles, analogous to the way electrical wires and network cables are merged into bundles along their joint paths and fanned out again at the end. This reduces visual clutter, inevitable in large graphs, allowing to find high-level edge patterns and get an overview of the graph just by looking at it. As example, US flights graph below, with nodes as airports and edges as flights.

### The algorithm

Edges are modeled as flexible springs that can attract each other while node positions remain fixed. A force-directed technique is used to calculate the bundling and it is relatively slow. On small graphs it works pretty fast due to optimizations, but consumes large amount of memory to store precomputed similar pairs of edges; for average and large graphs a special slow low-memory mode implemented. After every iteration preview is being refreshed, so it’s possible to observe formation of bundles in real-time.

Full algorithm description can be found on this research paper.

### Renderer Modes

FDEB has 3 renderer modes:

- Simple renderer: Draws all edges with the same color and transparency (color, transparency and thickness are set in the preview settings in the bottom-left panel), bundles are emphasized by combined transparency.
- Gradient renderer: Draws all edges with color from gradient slider. Edges that are similar to higher number of other edges get higher color.
- Gradient slow renderer: Uses more precise method to determine intensity of edge (needs precalculate points checkbox and to be re-runned) to set personal color for every segment.

FDEB can be **customized** with lots of options and they all have descriptions, some of the most influential on result are:

- Use inverse-qudratic model: Makes more localized bundling
- Compatibility threshold: Ignore pairs of edges that are not similar enough, which makes FDEB faster (ignored in low-memory mode) and bundling become more localized.

To make FDEB faster it’s also possible to decrease number of cycles/subdivision points increase rate.

### The Edge Layout API

An edge layout API has been created to simplify the integration of other edge layouts into Gephi. This API is very similar to the existing node layout API, with the following additions. Since edge layouts do not only change shapes of edges, but are also responsible for their visualization, a modifyAlgo() is called each time when the Preview is refreshed, to control the modification of parameters. The edge layout data, which is accessible for each edge, provides polyline points and it’s colors for all renderer modes.

### How to get the FDEB algorithm

It will be available in the **next release** of Gephi. The current source code is available on Github.

Hi Taras,

I’ve just seen this. Yes, FDEB gets sloooow on large graphs. Check out however KDEEB

http://www.cs.rug.nl/svcg/Shapes/KDEEB

(see paper and code)

for something 10x..50x faster, using OpenGL 1.1. Same idea, parallel implementation.

Best,

Alex

Looking forward to try FDEB!

[…] 后来改bug的过程中找到了一个比较好的Java实现： https://gephi.org/2012/gsoc-force-directed-edge-bundling/ […]

How can i use that. I have compiled it and start, but there isn`t a layout named FDEB?

Please help me.

This isn’t a node layout but an edges layout instead. In order to view its results you have to use the preview window.