Reducing visual clutter in Twilight

(1)

Bachelor Informatica

Reducing visual clutter in

Twilight

J.C. Bonsink (10172920)

June 20, 2014

Supervisor(s): Dr. R.G. Belleman (UvA)

I

n

f

o

r

m

a

t

ic

a

—

U

n

iv

e

r

s

it

e

it

v

a

n

A

m

s

t

e

r

d

a

m

(2)

(3)

Abstract

Data analysis plays an important role in many research areas, such as biology, micro-electronics, social sciences, data mining and computer science. One of the fundamental data analysis approaches is data visualization. The success of visual data analysis is the most re-liant on the cognitive skills of human analysts. Visually cluttered visualizations will prevent the analysts to use their skills effectively, possibly preventing critical insights. Visual clutter is present in most visualizations in Twilight. The supported node layout algorithms are not capable to create aesthetically pleasing results due to the sheer number of nodes and edges. New methods will be researched and implemented into Twilight to reduce visual clutter.

(4)

Introduction

Data analysis plays an important role in many research areas, such as biology, microelectron-ics, social sciences, data mining and computer science. One of the fundamental data analysis approaches is data visualization. The success of visual data analysis is the most reliant on the cognitive skills of human analysts. This approach presumes that “visual representations and interaction techniques take advantage of the human eye’s broad bandwidth pathway into the mind to allow users to see, explore, and understand large amounts of information at once. Infor-mation visualization focused on the creation of approaches for conveying abstract inforInfor-mation in intuitive ways.” [37]. It allows the discovery of unstructured actionable insights that are limited only by human imagination and creativity.

Graphs are widely used to visualize data in which information is comprised of objects and the relationship between these objects [28]. The objects are represented by the nodes of a graph, with the edges representing the relations. Node-link diagrams, in which nodes are drawn as points and edges as straight lines, are commonly employed to visualize graphs. The result of the visualization of the graphs is mostly depended on the position we choose to associate with each vertex of the graph. This mapping of vertices to positions is the embedding of the graph.

Improvements in data acquisition techniques have increased our ability to generate large data. This has driven the need for improved visualization, since manual drawing is not an option any more due to the increased size and complexity of the graphs. For particular classes of graphs, such as trees, planar graphs or directed acyclic graphs, effective visualization solutions have been found that provide very good results: not only in terms of time and space complexity but also in terms of aesthetic criteria. However, arbitrary graphs from the previously mentioned research areas usually do not belong to these classes.

Thankfully, scalable and high-quality algorithms exist to layout very large arbitrary graphs; these include force-directed algorithms, e.g. Frick [15], Gajer [18], Hachul [21] and Hu [25] and scalable multidimensional scaling algorithms, e.g. Brandes [5]. On many graphs, the node-link diagrams produced by these algorithms are often aesthetically pleasing and reveal intrinsic structure of the graphs. However, due to data complexity, we cannot expect that the algorithms can give a readable representation for all graphs. Lambert et al. even state that no drawing exists algorithm that offers a satisfying layout of a scale-free network (i.e. a graph whose degree distribution follows a power law).

For certain classes of graphs, a node-link diagram using straight edges is almost always difficult to comprehend. The layout algorithms themselves are often working correctly, in the sense that repositioning nodes can reveal meaningful node clusters. It is the sheer number of edges that clutter the visualization, as can be seen in figure 1.1. Furthermore, in some application domains, such as geography, changing node positions is prohibited. Geographical positions cannot be changed as they bring information. In these cases, information discovery becomes difficult as edge crossings and node-edge overlaps clutter the representation.

In cooperation with SURFsara the University of Amsterdam developed an interactive visu-alization tool, called ‘Twilight’, which is based on the igraph software package for for complex network research [6]. Twilight is suitable for visualizing general graphs as node-link diagrams.

(6)

Figure 1.1: An example of a visual cluttered graph.

Figure 1.2: The result of applying the Fruchterman-Reingold algorithm.

Compared to other visualization tools like Gephi [1], Twilight distinguishes itself by focussing on touch based input. Analyst have used Twilight to research criminal [10] and disease trans-mission networks [41]. To reduce visual clutter and to possibly provide the analyst with new insights, Twilight supports the following layout algorithms to reposition nodes: Kamada Kawai [26], Fruchterman-Reingold [17], GraphOpt [36, 6].

Figure 1.2 shows the result of applying the Fruchterman-Reingold algorithm on the graph visualized in Figure 1.1. The Fruchterman-Reingold algorithm is a force-directed algorithm that positions the graph nodes so that all edges are of more or less equal length and there are as few edge crossing as possible. The analyst is now able to clearly see three distinct clusters, but visual clutter still remains inside the clusters, thus preventing the visual identification of relationships between these nodes. Reducing the clutter in a graph representation is therefore of utmost importance to identify relationships and high-level edge patterns.

The goal of this thesis is to discover and implement methods to reduce visual clutter in Twilight. When addressing visual clutter in node-link diagrams, one can focus on the nodes, the edges or both. We will focus on both. The remainder of this thesis is organized as follows. Chapter 2 reviews previous work on reducing edge clutter. Chapter 3 introduces the various techniques, we chose to reduce visual clutter, in detail. Chapter 4 presents example visualiza-tions and performance benchmarks of the chosen techniques. Finally Chapters 5 and 6 present conclusions and directions for future work, respectively.

(7)

CHAPTER 2

Previous Work

To find suitable methods to reduce visual clutter in Twilight, we first give an overview of tech-niques that are commonly used for visualizing general graphs as node-link diagrams. This is followed by an overview of general methods that can be used to reduce visual clutter resulting from edge congestion. The next section focuses solely on edge bundling techniques for reducing edge clutter. Finally, some methods are presented to enhance edge-bundled graph visualizations.

2.1 Node-Link-Based Graph Visualization

The most well-known class of node-link-based visualization techniques for general graphs is the class of force-directed methods and its derivatives, e.g. Kamada-Kawai[26] and Fruchterman-Reingold [17]. An overview of additional techniques for specific kinds of graphs, such as directed acyclic graphs or trees, is presented by Battista [2], Herman [22] and Kaufmann [27].

Force-directed methods position graph nodes so that all edges are more or less equal length and there are as few edge crossings as possible. This is achieved by assigning forces as if the edges are springs and the nodes are electrically charged particles. The entire graph is then simulated as a physical system. Issues with regard to computational complexity and layout stability have recently been treated by various approaches, such as Koren [29] and Herman, [22]. GPU implementations, presented by Frishman [16], can significantly reduce computation time even further.

Force-directed methods are not suitable to reduce edge crossings in circular layouts. Baur and Brandes [3] propose a two-phase heuristic to reduce edge crossings by repositioning the nodes on the circle. While the first algorithm uses a greedy policy to build a good initial layout, an adaptation of the sifting heuristic for crossing reduction in layered layouts is used for local optimization in the second phase.

2.2 General Edge Clutter Reduction

Various techniques are available for the reduction of edge clutter. A general overview of tech-niques for reducing visual clutter, not specifically concerned with edge clutter reduction, is pre-sented by Ellis [13].

Visualizing graphs in a clustered way reduces edge clutter by drawing edges between clusters of nodes instead of individual edges between all nodes. Clustered graphs contain a hierarchical component in the form of a recursive clustering structure as well as non-hierarchical connections between the nodes of the clusters. Methods for drawing clustered graphs are presented by Eades et al. [12, 14] more general survey on drawing clustered graphs is provided by Kaufmann et al. [27]. A drawback of these methods is the necessity of the generation of a hierarchy and the fact that many low-level edges are fully merged into inter-cluster edges, making it impossible to discern individual edges.

(8)

The graph representation can be improved by forcing the edges to follow a specific route. Routing is a common problem in domains such as VLSI CAD and robotics. The physical con-straints play a major role in routing in these domains. In graph layout aesthetics play the more important role. For graphs, we seek paths that are easy to follow and do not intersect with node boundaries. Dobkin et al [9]. presents a general-purpose edge router that uses visibility graphs and shortest-path edge routing to remove node-edge overlaps. The technique was ported to tangent-visibility graphs by Wybrow [40]. However, construction of the full tangent-visibility graph is expensive, at least quadratic time in the number of nodes. Dwyer and Nachmanson [11] developed a fast heuristic to compute an approximation of the visibility graph to reduce the time complexity and therefore support larger graphs. These approaches efficiently reduce edge clutter by avoiding node-edge overlaps, however since no bundling is performed the analyst cannot discover high level edge patterns.

User interaction can be employed to reduce visual clutter. Interaction-based techniques such as EdgeLens and Edge Plucking by Wong [38, 39] can be used to manipulate edges. Edges close to the user’s focus of attention are pushed away in a fisheye-like manner without changing node positions. The representation is locally uncluttered around each focus, but this technique does not reduce the clutter of the entire representation. Furthermore, the use of such techniques is not an option in case of non-interactive graph visualization.

Becker et al. [4] use half-lines for the visualization of edges. A directed edge from source node A to target node B visualized as a half-line. Only the first half of the line between both nodes is shown. Although this reduces edge clutter, it is generally hard to identify the target node of a half-line.

2.3 Edge Clutter Reduction using Edge Bundling

Early work on reducing edge clutter using edge bundling focused on special classes of graph layouts. Therefore, the early methods could not be applied to general graphs. Newberry [33] proposed a technique for handling layered layouts of directed graphs. The technique identifies edges that form a complete bipartite graph, and routes these edges to pass through a common dummy node, thus eliminating crossings.

Flow maps reduce visual clutter by merging edges. Flow maps were usually drawn by hand by cartographers. Phan et al. present in [34], a method for generating flow maps using hierarchical clustering given a set of nodes, positions, and flow data between the nodes. The edges are routed along the hierarchy tree branches. The biggest drawback is that every edge split introduces too many routing nodes since all edge splits are binary. This can lead to extra clutter if too many nodes are added to a small area.

The idea, to route edges using a hierarchy tree, has also been used by Holten in [23]. Hi-erarchical Edge Bundling (HEB) bundles edges together by bending each edge, modelled as a B-spline curve, toward the polyline path defined by the available hierarchy. This method is not applicable to general graphs, since it requires a graph to contain a hierarchy. The bundles induced by the hierarchy should faithfully reflect the high-level edge patterns that are present in the graph. It is not evident which hierarchical-clustering scheme or spanning-tree generation method would be able to create a suitable hierarchy for for such a task.

Dickerson et al. [8] present a technique called confluent drawing for visualizing non-planar graphs in a planar way by allowing groups of edges to be merged and drawn together. This allows graphs, that would normally have many crossings, to be drawn in a crossing-free manner. The technique is based on the detection of maximum cliques and bi-cliques (complete bipartite graph). Then, edges are bundled to obtain a planar representation of these unplanar subgraphs. However, not every graph can be drawn confluently and in general it appears difficult to quickly determine beforehand whether or not this is the case.

Ganser and Koren [20] suggest three independent techniques for reducing visual clutter in circular layouts. The third technique reduces clutter by coupling groups of edges as bundled splines that share part of their route. Finally, Nachmanson et al. [35] shows how to improve the Sugiyama scheme by edge bundling. The bundles are created by an algorithm based on minimizing the total ink needed to draw the edges. To diminish the number of edge crossings

(9)

inside of the bundles, a metroline crossing minimization technique is applied.

Cui et al. [7] propose one of the first methods suitable for general graphs. Their method uses a control mesh to guide the bundling. Bundles are formed by forcing all edges to pass through some control points on the mesh. The control mesh can be generated at different levels of detail either manually or automatically based on underlying graph patterns. The algorithm was reported to be fast, although the resulting visualization was observed to exhibit a “webbing” effect [24], with edges having a high curvature variations. This can make such bundles hard to follow.

Holten and van Wijk [24] propose a Force-Directed Edge Bundling method. The method is conceptually simple, utilizing edges modelled as flexible springs that can attract each other. A compatibility measure between edges is computed to determine which of them should inter-act. The attractive force is proportional to the inverse distance of the springs, as well as to the compatibility of the edges. It was found to result in smoother bundles that are easy to read. The biggest drawback of this algorithm is its high computational complexity O(n2_{). The}

authors suggested that a Barnes-Hut like subdivision-based approach may be used to speed up the algorithm, though no implementation details were given.

Lambert et al. [31] propose an edge bundling algorithm that is also based on the use of a mesh. Graph edges are routed along mesh edges using a shortest path algorithm. Mesh edges weights are updated to encourage more graph edges to share common mesh edges. The algorithm was found to be faster than Holten’s force-directed bundling [24]. Further optimization in the use of shortest path algorithm and in parallelization made its speed close to that of the geometry-based bundling by Cui [7]. The method was subsequently extended to 3D by Lambert [30].

Previous methods for general graph layouts either require a control mesh to guide the bundling process or an all-to-all force and compatibility calculations, which is not scalable. Ganser et al. [19] propose a multilevel agglomerative edge bundling method based on a principled approach of minimizing ink needed to represent edges, with additional constraints on the curvature of the resulting splines. The proposed methods is much faster than the previous ones, able to bundle hundreds of thousands of edges in seconds.

2.4 Enhancing edge-bundled graph visualizations

All the edge-bundling techniques mentioned in the previous section share an important feature, the drawing of edges as curves. Drawing edges as curves makes it easier to follow their paths and it makes the graph more visually appealing. Different techniques have been used in the past to draw curves as smooth as possible. Holten renders bundled edges piecewise with cubic B-spline in his HEB technique [23]. Using B-splines, which offer local control on the curve shape, distinct and coherent bundles can be produced. Zhoe et al. [42] use Bezier curves and Catmull-rom splines to render bundled edges. Another method used by Holten et al. [24] and Cui et al. [7] is to apply a smoothing technique, e.g. Gaussian smoothing, on the edges drawn as polylines to morph them into curves.

It is difficult to follow individual edges in a bundle, when every edge has the same color and opacity. Once two edges are bundled, it is almost impossible for the analyst to know which source and target node belong to a certain edge. To overcome this drawback, different edge colors and opacities should be used to encode information. Cui et al. [7] maps edge colors to the directions of the original unbundled edges. A similar technique is used by Holten [23] but he chooses to encode direction by interpolating the color gradient running from a fixed color for the source to a fixed color for the target node. Holten maps edge opacities to edge lengths, lowering the opacity of long edges. Longer curves will therefore be more transparent than short ones, preventing short curves to become obscured. Cui et al. [7] maps the opacity of each segment of the polyline, representing an edge, to the density of line overlapping it. To estimate the amount of edge overlap Holten [24] proposes a GPU-based method to compute the amount of overdraw for each pixel of the produced graph visualization. The calculated overdraw is then used to map pixel colors to a gradient color scale.

(10)

CHAPTER 3

Methods

From the techniques mentioned in the previous section, two were chosen to be implemented in Twilight: Crossing Reduction in Circular Layouts by Baur and Brandes [3] and Force-Directed Edge Bundling by Holten and van Wijk [24].

3.1 Crossing Reduction in Circular Layouts

The default graph layout in Twilight is the circular layout. In this layout, the vertices are constrained to distinct positions along the perimeter of a circle. The initial node order on the circle is determined by the node’s ID attribute. Note that, similar to 2-layer layouts, the number of crossings is completely determined by the ordering of the vertices, as can be seen in Figure 3.1. A suboptimal node order can lead to a high amount of edge crossings and thus increasing the visual clutter. Thankfully, the number of edge crossings in such layouts can be minimized by finding an optimal node order. The approach proposed by Baur and Brandes in [3] will be used to accomplish this.

Baur and Brandes propose a two-phase approach for obtaining circular layouts with few crossings. In the first phase, vertices are iteratively added to either end of a linear layout. This leaves three degrees of freedom: the start vertex, the insertion order and the end at which to append the next vertex. For the second phase, an adaptation of sifting [32], a local optimization procedure for layered layouts, is used to further reduce the number of crossings.

Figure 3.1: The amount of edge crossings is significantly reduced in the right figure by reordering the nodes on the circular layout.

(11)

3.1.1 Initial layout

The basic idea behind Baur and Brandes’s approach is simple: start with a layout consisting of a single vertex and place the other vertices, one at a time, at either end of the current linear layout. After all vertices are inserted, the final layout is considered to be circular. This leaves three degrees of freedom: the start vertex, the insertion order and the end at which to append the next vertex.

Baur and Brandes suggest to choose the starting vertex at random. In their experiments, the rules for choosing a start vertex had little influence on the final result. The implementation in Twilight chooses the vertex with the highest degree as the start vertex.

During each step of the algorithm a vertex is placed on the layout. Baur and Brandes experimented with four rules for determining this selection. The rationale behind these heuristics is to keep the number of open edges low. An edge is called open, if one of its endpoints is still unplaced, and closed, if both endpoints have been inserted.

1. Degree. Vertices are inserted in non-increasing order of their degree.

2. Inward Connectivity. At each step, the vertex with the largest number of already placed neighbours is selected, i.e. a vertex which closes the most open edges.

3. Outward Connectivity. At each step, the vertex with the least number of unplaced neigh-bours is selected, i.e. a vertex which opens the fewest new edges.

4. Connectivity. At each step, the vertex with the largest number of already placed neighbours is selected. When multiple vertices are applicable, the vertex with the fewest unplaced neighbours is selected.

The final degree of freedom left is the selection of the end of the current layout which to append the next vertex. Again, four rules are investigated.

1. Random. Select the end at which to append randomly each time. 2. Fixed. Always append to the same end.

3. Length. Append each vertex to the end that yields the smaller increase in total edge length. 4. Crossings. Append each vertex to the end that yields fewer crossing of edges being closed

with open edges.

Analysis of the experiments concluded that using the Connectivity insertion order and the

Crossings placement rule was the most effective in minimizing edge crossings. The Length

place-ment rule can be used as an alternative for the Crossings rule since it only performed slightly worse. In Twilight the Connectivity insertion order is implemented in combination with the

Length placement rule.

Baur and Brandes suggest using a two-dimensional priority queue to store all unplaced neigh-bours, in which the first key gives the number of already placed neighbours and the second the number of unplaced neighbours. Update and extract operations require O(log n) time with an efficient implementation. The total running time for determining the insertion order is O((n+m) log n), with n the number of vertices and m the number of edges. During the algorithm each vertex is extracted once, and each edge triggers exactly one update.

3.1.2 Improvement by Circular Sifting

The algorithm, introduced in the previous section, does not guarantee that the edge crossings are optimally minimized. Further minimization can be accomplished using a technique called sifting. Sifting was originally introduced as a heuristic for vertex minimization in ordered binary decision diagrams and later adapted for the one-side crossing minimization problem. The idea is to keep track of the objective function while moving a vertex along a fixed ordering of all other vertices. For crossing reduction the objective function is the number of crossings between the

(12)

Figure 3.2: Edge crossing in the left figure is reduced by swapping the top vertices.

edges incident to the vertex under consideration and all other edges. The vertex is then placed in its locally optimal position.

We define the crossing count as

cuv(π) = X x∈N (u) X y∈N (v) χπ({u, x}, {v, y}) (3.1)

only for pairs of consecutive vertices u y v ∈ V . It is computed by considering only edges incident to one of these vertices. The positions of the endpoints of the edges are the key to determine the occurrence of an edge crossing. For example, in the right figure in Figure 3.2 the green edges v, v2and u, u1are crossing because vertex u1lies between v and v2, and v2between

u1and u. The positions of the endpoints are alternating on the circle during a clockwise traversal.

The locally optimal position of a single vertex can be found by iteratively calculating the crossing count of two consecutive vertices on the circle. The two vertices are swapped if this reduces the crossing count. Processing each pair of consecutive vertices is called a round of circular sifting. Two or three rounds should be sufficient to optimally minimize the crossing count. Figure 3.2 shows how the swapping of two vertices can significantly reduce the crossing count. The crossing count of vertices v and u in the left figure is three. Swapping the positions of v and u reduces the crossing count to one.

3.2 Force-Directed Edge Bundling

The Force-Directed Edge Bundling (FDEB) method by Holten [24] is one of the few bundling techniques for general graphs that can create smooth bundles that are easy to read. Furthermore, its behaviour is easy to understand because of the straightforward physics model, the core algo-rithm can be implemented in a few lines of code, and it can easily be extended to accommodate for additional layout criteria.

3.2.1 Core Technique

The initial input for the FDEB technique is a straight-line node-link diagram of a general graph G. This node-link diagram can be generated using any of the available graph layout techniques in Twilight.

To be able to curve straight-line edges while bundling, edges in G are subdivided into segments by introducing subdivision points. Figure 3.3 shows the result of subdividing edge P into five segments using four subdivision points. While bundling, only the positions of the subdivision points pi are subject to change. The positions of the source and target nodes P0 and P1 remain

fixed.

An electrostatic force Feis used to attract subdivision points of different edges to each other.

(13)

Figure 3.3: Edge P with subdivision points p0, p1, p2, p3.

Figure 3.4: The calculation of Febetween points

p2 and q2.

Fe= 1/kpi− qik. Alternatively, an inverse-square model can be used which results in stronger,

more localized bundling. Feis calculated for each pair of corresponding subdivision points of a

pair of interacting edges. Thus there are four Fe interaction in Figure 3.4: between p0 and q0,

p1and q1, p2 and q2, p3 and q3. Fecould also be calculated for each combination of subdivision

points (p, q) with p ∈ P and q ∈ Q. However, this would significantly increase the computational complexity from O(N ) to O(N2_{) for the calculation of the attractive forces with N subdivision}

points per edge. Furthermore, Holten observed that the resulting bundling of both approaches do not much differ from a visual standpoint.

The edges are modelled as flexible springs, to counteract the attractive electrostatic forces. Each segment is modelled as a zero-length spring, a spring that exerts zero force when its length is zero. To influence the degree of bundling in a graph a global spring constant K is used to control the stiffness of the edges. For each couple of consecutive subdivision points, the spring force Fs is calculated as Fs = kp· (kpi−1− pik). Figure 3.5 shows how the two neighbouring

spring forces Fsare calculated for p2. The resulting force exerted on a subdivision point increases

linearly as the distance between the subdivision point and its two neighbouring points increases. Since edges in the graph have different initial lengths, a local spring constant kp is calculated for

each edge P . The local spring constant is identical for each segment of P and is calculated as kp= (_{|P |}K) · N , where |P | is the initial length of edge P and N is the number of segments. This

guarantees that all springs are of relatively equal strength, throughout the bundling process. The combined force exerted on each subdivision point of every edge is calculated during each calculation step of the iterative simulation. The position of the subdivision point is updated by moving it in the direction of the combined force that is exerted on it. For subdivision point p2

on edge P in Figure 3.5, the combined force Fpi exerted on this point is a combination of the

two neighbouring spring forces Fs exerted by p1 and p3 and the sum of all electrostatic forces

Fe. It is defined as

Fpi = kp· Fs+ Fe

= kp· (kpi−1− pik + kpi− pi+1k) + ΣQ∈E

1 kpi− qik

(14)

Figure 3.6: Angle compatibility. Figure 3.7: Scale compatibility.

3.2.2 Compatibility measures

The model presented in the previous section is incomplete. It generates an edge-bundled graph, but the amount of bundling is too high. Too many edges are bundled with each other. Although this could be remedied by increasing the value of the global spring constant K, Holten mentions that making the edges stiffer also results in less bundling in parts of the graph where a high amount of bundling is desirable. To reduce the amount of interaction between edges, Holten introduces a set of edge compatibility measures.

In general, edges that are almost perpendicular should not be bundled together. Holten therefore introduces the concept of angle compatibility Ca(P, Q) ∈ [0, 1] as

Ca(P, Q) = |cos(α)|

α = arccos( P · Q |P | · |Q|)

This is illustrated in Figure 3.6. The larger the angle α between P and Q, the smaller value of Ca(P, Q). Ca(P, Q) equals zero when P and Q are orthogonal and equals one in the most

optimum case, when P and Q are parallel.

Edges that differ considerably in length should not be bundled together either. This would result in noticeable stretching and curving of short edges to accommodate to the shape of long edges, as is illustrated in Figure 3.8. Holten therefore introduces the concept of scale compatibility Cs(P, Q) ∈ [0, 1] as

Cs(P, Q) =

2

lavg· min(|P |, |Q|) +max(|P |,|Q|)_l_a_vg

lavg =

|P | + |Q| 2

This is illustrated in Figure 3.7. The larger the difference in length between P and Q, the smaller of Cs(P, Q). Cs(P, Q) equals one in the most optimum case when P and Q have equal

length and it approaches zero if the ratio between the longest and shortest edges approaches ∞. Edges that are far apart should not be bundled together either. Holten therefore introduces the concept of position compatibility Cp(P, Q) ∈ [0, 1] as

Figure 3.8: Example of a short edge that is noticeably stretched and curved after bundling with a considerably lengthier edge. Original edges, curved edges and attracting forces are shown in black, blue and red, respectively.

(15)

Figure 3.9: Position compatibility. Figure 3.10: Visibility compatibility.

Cp(P, Q) =

lavg

lavg+ kPm− Qmk

with Pm and Qm as the midpoints of edges respectively P and Q.

This is illustrated in Figure 3.9. Cp(P, Q) equals one in the most optimum case when Pm

and Qmcoincide and approaches zero if the distance between Pm and Qm approaches infinity.

However, it is possible that edges are parallel, equal in length and close together, but should nevertheless have a fairly low bundling-compatibility. The opposite edges of a skewed parallelo-gram are an example of this, see Figure 3.10. To address this, Holten also introduces the concept of visibility compatibility Cv(P, Q) ∈ [0, 1] as

Cv(P, Q) = min(V (P, Q), V (Q, P ))

V (P, Q) = max(1 −2 · kPm− Imk kI0− I1k

with Imas the midpoint of I0and I1.

This is illustrated in Figure 3.10. V (P, Q) is the visibility of P to Q and is determined by extending a “band of sight” from Q and calculating the intersection points I0and I1of this band

with the extended line P . Cv(P, Q) equals one in the most optimum case when Pm coincides

with the intersection midpoint Im. Cv(P, Q) equals zero if P is moved outside the band of sight

along its extended line.

The total edge compatibility Ce(P, Q) ∈ [0, 1] between edges P and Q is defined as

Ce(P, Q) = Ca(P, Q) · Cs(P, Q) · Cp(P, Q) · Cv(P, Q)

The combined force Fpi is now redefined as

Fpi = kp· (kpi−1− pik + kpi− pi+1k) + ΣQ∈E

Ce(P, Q)

kpi− qik

3.2.3 Calculation

Holten suggests an iterative refinement scheme to increase the performance of the bundling. The simulation starts with an initial number of subdivision points P0for each edge and an initial step

size S0. The step size S determines the distance a subdivision point is moved at each iteration

in the direction of the combined force that is exerted on it. Furthermore, a fixed number of simulation cycles C is performed. A specific number of iteration steps I is performed during each cycle.

After performing a cycle, the number of subdivision points P is doubled and the step size S is halved before starting the next cycle. The number of iteration steps I per cycle is decreased by a factor. Finding parameters that prove to be satisfactory takes some experimenting. Holten settled for P0= 1, S0= 0.04, C = 6 and I0= 50. Those parameters worked satisfactory for his

test graphs.

The initial step size should be chosen as high as possible without destabilizing the simulation. An equilibrium will be found more quickly, when a high value is chosen. Since the points will

(16)

move greater distances during each iteration, less iteration steps will be needed to complete the bundling. The drawback is that high values for S0can cause oscillating movement of subdivision

points. Holten mentions using a local cooling scheme can dampen the oscillation but he does not provide any details.

The oscillating movement can be prevented by ensuring that the displacement of a point will not be larger than the previous displacement. This will ensure that a point will not overshoot its equilibrium when its position is updated. A local step size is assigned to each edge. This step size can be updated during each iteration. When the displacement is larger than the previous displacement, the updated step size is calculated as

Si= Si−1·

Di−1

Di

(3.2) with Di as the displacement of a point during iteration i. Di is recalculated using the new

value of Si. Note that the step size value will decrease rather quickly. When the value is too low

subdivision points, added during later cycles, will not move any more, creating ‘jagged edges’. This can be remedied by increasing the stepping size value at the beginning of each cycle. It is advised to use a low number of initial iteration steps.

To further increase the performance without comprising the bundling result, Holten suggests to use a threshold for the total edge compatibility Ce(P, Q). A pair of edges P and Q is only

considered for calculation if Ce(P, Q) is above a certain threshold. The total number of edge

interactions can drop to 25%-50% of the total as a result of this, even for small threshold values such as 0.05.

(17)

CHAPTER 4

Experiments

This section presents the results of the techniques used to reduce visual clutter in Twilight. Results of the edge crossing reduction method are presented in section 4.1. Section 4.2 present the results of the FDEB method. Several example visualizations in the first subsection of each section while some performance benchmarks are provided in second subsection. All measurements were performed on an Intel Core i5-4200 with 8192MB RAM.

4.1 Crossing Reduction in Circular Layouts

4.1.1 Aesthetics

The Crossing Reduction method has been tested on several generated datasets and genuine datasets that have been used by analysts in the past. The graphs will be shown in pairs. The left figure is the graph with the default layout, where the node order is determined by the node’s ID attribute. The right figure is the graph with the optimal node order calculated by the Crossing Reduction method.

Generated datasets

The generated datasets used for the following figures contain 100 vertices with a minimal degree of one. Figure 4.1 and 4.2 shows that when the maximum degree of the vertices in the graph is one, the graph can be drawn as a planar graph.

(18)

Figure 4.3: Maximum degree 4 - 190 edges. Figure 4.4: Edge crossings reduced.

(19)

The maximum degree of a vertex in the graph increases through Figures 4.3,4.5, 4.7, 4.9. The effect that the reordering of the nodes has on the amount of edge crossings diminishes as the maximal degree increases, seen Figure 4.10.

Genuine datasets

The graph in Figure 4.11 depicts a social network containing 894 nodes and 25119 edges. Three clusters reside in this network, which can be found using a layout algorithm, e.g. Fruchterman-Reingold. Figure 4.12 shows that the three clusters can also be found using the crossing reduction method.

Figure 4.11: Social network containing three clusters.

(20)

Figure 4.13: The 500 largest airports in the US. Figure 4.14: Edge crossings reduced.

The graph in Figure 4.13 depicts the 500 largest airports in the US and 2980 connecting airlines.

Figure 4.15: HIV spread network. Figure 4.16: Edge crossings reduced. The graph in Figure 4.15 depicts the spread of hiv inside a network. The graph contains 1471 nodes and 7954 edges.

(21)

4.1.2 Performance

The time measurements are taken for the entire Crossing Reduction method, thus including the creation of the initial layout and one round of sifting. To discover the influence of the amount of edges and nodes on the computation time, three experiments are performed. During each experiment the degree of the nodes remains constant. The only variable is the amount of nodes. The results are presented in Figures 4.17 and 4.18.

Figure 4.17: Time in milliseconds vs. amount of vertices.

(22)

4.2 Force-Directed Edge Bundling

4.2.1 Aesthetics

The FDEB methods has been tested on several genuine datasets. By default Twilight renders all lines using the same color and transparency. This has been changed for the bundling process. Longer edges have a less transparent than shorter ones. This emphasizes the bundling of the longer edges, thus making the discovery of high level patterns more easily.

Inverse-linear vs. Inverse-quadratic Fe

An electrostatic force Feis used to attract subdivision points of different edges to each other. Fe

is proportional to the inverse distance between the interacting points. Alternatively, an inverse-square model can be used. The results of both models are presented in this section.

Figure 4.19: A straight line graph depicting US airlines.

(23)

Figure 4.21: The result of bundling Figure 4.19 using FDEB with the inverse-quadratic model.

Figure 4.22: A straight line circular graph depicting word adjacencies.

Figure 4.23: The result of bundling Fig-ure 4.22 using FDEB with the inverse-linear model.

(24)

Figure 4.25: A straight line circular graph depicting the 500 largest US airports.

Figure 4.26: The result of bundling Fig-ure 4.25 using FDEB with the inverse-linear model.

Figure 4.27: The result of bundling Fig-ure 4.25 using FDEB with the inverse-quadratic model.

Dynamic time step vs. Static time step

Choosing a correct initial time step, S0 is critical to get decent results. High values can cause

oscillating movement of subdivision points. Low values prevent this, but more iteration steps will be needed to complete the bundling. The local cooling scheme assigns a dynamic time step to each edge. The value of this local time step is changed during each iteration in order to prevent each oscillation. The usage of this scheme should allow us to use a high value for S0. The results

are presented in this section.

The parameters used for the following experiments are: P0= 3 and C = 4. The number of

iterations is decreased with 0.7 after each cycle. The bundling of the airlines graph in Figure 4.28 was accomplished with I0 = 125 and S0= 0.01. Figure 4.29 shows the result of using the

local cooling scheme with I0= 60 and S0= 8.0 I0= 125, S0= 0.001 and I0= 60, S0= 4.0 was

(25)

Figure 4.28: The result of bundling Figure 4.19 using FDEB with the with the static time step.

Figure 4.29: The result of bundling Figure 4.19 using FDEB with the dynamic time step.

Figure 4.30: The result of bundling Figure 4.22 using FDEB with the static time step.

Figure 4.31: The result of bundling Figure 4.22 using FDEB with the dynamic time step.

(26)

Crossing Reduction

Edge bundling may produce more aesthetically pleasing reduced when used in combination with the Crossing Reduction method. The results are presented in this section.

Figure 4.32: The result of applying the crossing reduction method to the word adjacencies graph, see Figure 4.22.

Figure 4.33: The result of bundling Figure 4.32 using FDEB with the inverse-linear model.

(27)

Figure 4.35: The result of applying the crossing reduction method to the US airports graph, see Figure 4.25

(28)

Layout algorithms

Twilight supports several layout algorithms. They are great for discovering clusters but they often produce heavily visually cluttered graphs. Edge bundling may reduce this. The results are presented in this section.

Figure 4.38: The result of applying the Fruchterman-Reingold algorithm on Figure 4.25.

Figure 4.40: The result of applying the Kamada-Kawai algorithm on Figure 4.25.

(29)

4.2.2 Performance

The edge bundling process consists of two distinct phases. The compatibility measure between edges is computed in the first phase to determine which of the edges should interact. The actual bundling by updating the positions of the subdivision points happens in the second phase. The performance experiments are therefore split in two parts.

The computation time to calculate the edge compatibilities, is solely dependent on the amount of edges present in the graph. Several datasets (generated and genuine) have been used in this experiment.

Figure 4.42: Time in milliseconds vs. amount of edges.

(30)

The time measurements are taken for two separate conditions. The amount of nodes in the first one is constant but the maximum degree of the vertices is variable, see Figure 4.44. The degree of the vertices in the second one is constant but the amount of vertices is variable, see Figure 4.45. A correlation could not be found between time and the number of compatible edge pairs, when both the number of nodes and the degree were variable.

Figure 4.44: Time in milliseconds vs. amount of compatible edge pairs. Constant number of nodes.

Figure 4.45: Time in milliseconds vs. amount of compatible edge pairs. Constant degree for every vertex.

(31)

CHAPTER 5

Conclusions

Twilight only supported several layout algorithms. They are capable to reposition nodes to reveal meaningful node clusters. However, creating aesthetically pleasing layouts with these algorithms is often a difficult task. The sheer number of edges and nodes clutter the visualization. Furthermore, in some application domains, such as geography, changing the node positions is prohibited. To provide Twilight with more tools to reduce visual clutter, two methods are implemented: Crossing Reduction in Circular Layouts by Baur and Brandes [3] and Force-Directed Edge Bundling (FDEB) by Holten and van Wijk [24].

The default graph layout in Twilight is the circular layout. The visual clutter in circular layouts is mainly caused by edge crossings, which is dependent on the node order. The default order in Twilight is determined by the node’s ID attribute, which will most likely lead to a high amount of edge crossings and thus increasing visual clutter. Thankfully, an optimal node order can be calculated using the Crossing Reduction method. It consists of two phases: in the first phase, an initial layout is created by greedily appending vertices to either end of a linear layout according to some criteria, and initial layout is further improved in the second phase by repeatedly sifting each vertex to a locally optimal position.

Just like layout algorithms, this algorithm is also capable in revealing clusters. Unfortunately, the experiments have shown that this method has limited capabilities for reducing visual clut-ter. It works really well for graphs with limited amounts of vertices and edges, but its effects diminishes when the number of vertices and the average degree increases. The method performs rather well, it can process a graph containing 10.000 nodes in less than 30 seconds. The time complexity is O(n log(n)).

Edge bundling is used to further reduce visual clutter in Twilight. The FDEB method is one of the few bundling techniques suitable for general graphs that can create smooth bundles that are easy to read. Edges are modelled as flexible springs that can attract each other. A global spring constant K is used to control the stiffness of the springs and thus the amount of bundling. Compatibility measures are used to prevent incompatible edges to be bundled together. The resulting bundled graphs show significant clutter reduction and clearly visible high-level edge patterns.

An electrostatic force is used to attract edges to each other. The force is proportional to the inverse distance between the interacting edges. Alternatively, an inverse-square model can be used resulting in more localized bundles. Experiments have shown that this option is best suitable for circular layouts.

During the bundling process a time step is used that determines the distance the edge can move during each iteration. High values can cause oscillating movement, while lower values will prevent this more iterations steps will be needed to complete the process. A local cooling scheme was developed to assign dynamic time steps to each edge, which would be updated each iteration to prevent oscillation. Experiments have show that using this scheme reduces the quality of the bundling. The local time steps are reduced too quickly, preventing edges to move in later iterations. Thus, it is better to use more iterations and a static time step to generate smoother and tight bundles.

(32)

Though generating aesthetically pleasing results, FDEB is not scalable. The time complexity is O(n2_{) for both the calculation of the compatibility measures and the all-to-all forces.}

The success of visual data analysis is the most reliant on the cognitive skills of the human analysts. Reducing visual clutter in Twilight provides analysts with better visualizations in order for them to use their skills more effectively, possibly gaining more insights. It is for the reader to decide whether the two methods implemented in Twilight have been successful in doing so.

(33)

CHAPTER 6

Future Work

The implemented edge bundling method requires an all-to-all force and compatibility calcula-tions, which is not scalable. The method presented by Ganser et al. [19] is much faster and able to bundle hundreds of thousands of edges in seconds. They propose a multilevel agglomerative edge bundling method based on a principled approach of minimizing ink needed to represent edges, with additional constraints on the curvature of the resulting splines.

The edge-bundled graph visualizations can be further enhanced by improving the rendering technique used in Twilight. It is still difficult to follow individual edges in a bundle, when every edge has the same color. Once two edges are bundled, it is almost impossible for the analyst to know which source and target node belong to a certain edge. To overcome this drawback opacities are mapped to edge lengths, lowering the opacity of shorter curves. However, shorter curves will therefore become more obscured.

Cui et al. [7] maps edge colors to the directions of the original unbundled edges. A similar technique is used by Holten [23] but he chooses to encode direction by interpolating the color gradient running from a fixed color for the source to a fixed color for the target node. Cui et al. [7] maps the opacity of each segment of the polyline, representing an edge, to the density of line overlapping it. To estimate the amount of edge overlap Holten [24] proposes a GPU-based method to compute the amount of overdraw for each pixel of the produced graph visualization. The calculated overdraw is then used to map pixel colors to a gradient color scale.

(34)

Bibliography

[1] Mathieu Bastian, Sebastien Heymann, and Mathieu Jacomy. Gephi: an open source software for exploring and manipulating networks. In ICWSM, pages 361–362, 2009.

[2] Giuseppe Di Battista, Peter Eades, Roberto Tamassia, and Ioannis G Tollis. Graph drawing:

algorithms for the visualization of graphs. Prentice Hall PTR, 1998.

[3] Michael Baur and Ulrik Brandes. Crossing reduction in circular layouts. In Graph-Theoretic

Concepts in Computer Science, pages 332–343. Springer, 2005.

[4] Richard A. Becker, Stephen G. Eick, and Allan R. Wilks. Visualizing network data.

Visu-alization and Computer Graphics, IEEE Transactions on, 1(1):16–28, 1995.

[5] Ulrik Brandes and Christian Pich. An experimental study on distance-based graph drawing. In Graph Drawing, pages 218–229. Springer, 2009.

[6] Gabor Csardi and Tamas Nepusz. The igraph software package for complex network research.

InterJournal, Complex Systems, 1695(5), 2006.

[7] Weiwei Cui, Hong Zhou, Huamin Qu, Pak Chung Wong, and Xiaoming Li. Geometry-based edge clustering for graph visualization. Visualization and Computer Graphics, IEEE

Transactions on, 14(6):1277–1284, 2008.

[8] Matthew Dickerson, David Eppstein, Michael T Goodrich, and Jeremy Yu Meng. Confluent drawings: visualizing non-planar diagrams in a planar way. In Graph Drawing, pages 1–12. Springer, 2004.

[9] David P Dobkin, Emden R Gansner, Eleftherios Koutsofios, and Stephen C North. Im-plementing a general-purpose edge router. In Graph Drawing, pages 262–271. Springer, 1997.

[10] Paul AC Duijn, Victor Kashirin, and Peter MA Sloot. The relative ineffectiveness of criminal network disruption. Scientific reports, 4, 2014.

[11] Tim Dwyer and Lev Nachmanson. Fast edge-routing for large graphs. In Graph Drawing, pages 147–158. Springer, 2010.

[12] Peter Eades, Qing-Wen Feng, and Xuemin Lin. Straight-line drawing algorithms for hierar-chical graphs and clustered graphs. In Graph drawing, pages 113–128. Springer, 1997. [13] Geoffrey Ellis and Alan Dix. A taxonomy of clutter reduction for information visualisation.

Visualization and Computer Graphics, IEEE Transactions on, 13(6):1216–1223, 2007.

[14] Qingwen Feng. Algorithms for drawing clustered graphs. PhD thesis, Citeseer, 1997. [15] Arne Frick, Andreas Ludwig, and Heiko Mehldau. A fast adaptive layout algorithm for

undirected graphs (extended abstract and system demonstration). In Graph Drawing, pages 388–403. Springer, 1995.

(35)

[16] Yaniv Frishman and Ayellet Tal. Multi-level graph layout on the gpu. Visualization and

Computer Graphics, IEEE Transactions on, 13(6):1310–1319, 2007.

[17] Thomas MJ Fruchterman and Edward M Reingold. Graph drawing by force-directed place-ment. Software: Practice and experience, 21(11):1129–1164, 1991.

[18] Pawel Gajer, Michael T Goodrich, and Stephen G Kobourov. A fast multi-dimensional algorithm for drawing large graphs. In Graph Drawing00 Conference Proceedings, pages 211–221, 2000.

[19] Emden R Gansner, Yifan Hu, Stephen North, and Carlos Scheidegger. Multilevel agglomer-ative edge bundling for visualizing large graphs. In Pacific Visualization Symposium

(Paci-ficVis), 2011 IEEE, pages 187–194. IEEE, 2011.

[20] Emden R Gansner and Yehuda Koren. Improved circular layouts. In Graph Drawing, pages 386–398. Springer, 2007.

[21] Stefan Hachul and Michael J¨unger. Drawing large graphs with a potential-field-based mul-tilevel algorithm. In Graph Drawing, pages 285–295. Springer, 2005.

[22] Ivan Herman, Guy Melan¸con, and M Scott Marshall. Graph visualization and navigation in information visualization: A survey. Visualization and Computer Graphics, IEEE

Transac-tions on, 6(1):24–43, 2000.

[23] Danny Holten. Hierarchical edge bundles: Visualization of adjacency relations in hierarchical data. Visualization and Computer Graphics, IEEE Transactions on, 12(5):741–748, 2006. [24] Danny Holten and Jarke J Van Wijk. Force-directed edge bundling for graph visualization.

In Computer Graphics Forum, volume 28, pages 983–990. Wiley Online Library, 2009. [25] Yifan Hu. Efficient, high-quality force-directed graph drawing. Mathematica Journal,

10(1):37–71, 2005.

[26] Tomihisa Kamada and Satoru Kawai. An algorithm for drawing general undirected graphs.

Information processing letters, 31(1):7–15, 1989.

[27] Michael Kaufmann and Dorothea Wagner. Drawing graphs: methods and models, volume 2025. Springer, 2001.

[28] Daniel A Keim. Information visualization and visual data mining. Visualization and

Com-puter Graphics, IEEE Transactions on, 8(1):1–8, 2002.

[29] Yehuda Koren, Liran Carmel, and David Harel. Ace: A fast multiscale eigenvectors compu-tation for drawing huge graphs. In Information Visualization, 2002. INFOVIS 2002. IEEE

Symposium on, pages 137–144. IEEE, 2002.

[30] Antoine Lambert, Romain Bourqui, and David Auber. 3d edge bundling for geographical data visualization. In Information Visualisation (IV), 2010 14th International Conference, pages 329–335. IEEE, 2010.

[31] Antoine Lambert, Romain Bourqui, and David Auber. Winding roads: Routing edges into bundles. In Computer Graphics Forum, volume 29, pages 853–862. Wiley Online Library, 2010.

[32] Christian Matuszewski, Robby Sch¨onfeld, and Paul Molitor. Using sifting for k-layer straightline crossing minimization. In Graph Drawing, pages 217–224. Springer, 1999. [33] Frances J Newbery. Edge concentration: A method for clustering directed graphs. In ACM

SIGSOFT Software Engineering Notes, volume 14, pages 76–85. ACM, 1989.

[34] Doantam Phan, Ling Xiao, Ron Yeh, and Pat Hanrahan. Flow map layout. In Information

(36)

[35] Sergey Pupyrev, Lev Nachmanson, and Michael Kaufmann. Improving layered graph layouts with edge bundling. In Graph Drawing, pages 329–340. Springer, 2011.

[36] Michael Schmuhl. Graphopt. http://www.schmuhl.org/graphopt/, 2003. [Online; ac-cessed 15-April-2014].

[37] James J Thomas and Kristin A Cook. A visual analytics agenda. Computer Graphics and

Applications, IEEE, 26(1):10–13, 2006.

[38] Nelson Wong and Sheelagh Carpendale. Interactive poster: Using edge plucking for inter-active graph exploration. In Poster in the IEEE Symposium on Information Visualization, 2005.

[39] Nelson Wong, Sheelagh Carpendale, and Saul Greenberg. Edgelens: An interactive method for managing edge congestion in graphs. In Information Visualization, 2003. INFOVIS

2003. IEEE Symposium on, pages 51–58. IEEE, 2003.

[40] Michael Wybrow, Kim Marriott, and Peter J Stuckey. Incremental connector routing. In

Graph Drawing, pages 446–457. Springer, 2006.

[41] Narges Zarrabi, Mattia Prosperi, Robert G Belleman, Manuela Colafigli, Andrea De Luca, and Peter MA Sloot. Combining epidemiological and genetic networks signifies the impor-tance of early treatment in hiv-1 transmission. PloS one, 7(9):e46156, 2012.

[42] Hong Zhou, Xiaoru Yuan, Weiwei Cui, Huamin Qu, and Baoquan Chen. Energy-based hierarchical edge clustering of graphs. In Visualization Symposium, 2008. PacificVIS’08.

Reducing visual clutter in Twilight

Bachelor Informatica