Results 1  10
of
18
ForceDirected Edge Bundling for Graph Visualization
, 2009
"... Graphs depicted as nodelink diagrams are widely used to show relationships between entities. However, nodelink diagrams comprised of a large number of nodes and edges often suffer from visual clutter. The use of edge bundling remedies this and reveals highlevel edge patterns. Previous methods requ ..."
Abstract

Cited by 37 (0 self)
 Add to MetaCart
Graphs depicted as nodelink diagrams are widely used to show relationships between entities. However, nodelink diagrams comprised of a large number of nodes and edges often suffer from visual clutter. The use of edge bundling remedies this and reveals highlevel edge patterns. Previous methods require the graph to contain a hierarchy for this, or they construct a control mesh to guide the edge bundling process, which often results in bundles that show considerable variation in curvature along the overall bundle direction. We present a new edge bundling method that uses a selforganizing approach to bundling in which edges are modeled as flexible springs that can attract each other. In contrast to previous methods, no hierarchy is used and no control mesh. The resulting bundled graphs show significant clutter reduction and clearly visible highlevel edge patterns. Curvature variation is furthermore minimized, resulting in smooth bundles that are easy to follow. Finally, we present a rendering technique that can be used to emphasize the bundling.
Online Dynamic Graph Drawing
"... This paper presents an algorithm for drawing a sequence of graphs online. The algorithm strives to maintain the global structure of the graph and thus the user’s mental map, while allowing arbitrary modifications between consecutive layouts. The algorithm works online and uses various execution cu ..."
Abstract

Cited by 33 (1 self)
 Add to MetaCart
This paper presents an algorithm for drawing a sequence of graphs online. The algorithm strives to maintain the global structure of the graph and thus the user’s mental map, while allowing arbitrary modifications between consecutive layouts. The algorithm works online and uses various execution culling methods in order to reduce the layout time and handle large dynamic graphs. Techniques for representing graphs on the GPU allow a speedup by a factor of up to 17 compared to the CPU implementation. The scalability of the algorithm across GPU generations is demonstrated. Applications of the algorithm to the visualization of discussion threads in Internet sites and to the visualization of social networks are provided.
GeometryBased edge clustering for graph visualization
 IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS
, 2008
"... Graphs have been widely used to model relationships among data. For large graphs, excessive edge crossings make the display visually cluttered and thus difficult to explore. In this paper, we propose a novel geometrybased edgeclustering framework that can group edges into bundles to reduce the ove ..."
Abstract

Cited by 25 (2 self)
 Add to MetaCart
Graphs have been widely used to model relationships among data. For large graphs, excessive edge crossings make the display visually cluttered and thus difficult to explore. In this paper, we propose a novel geometrybased edgeclustering framework that can group edges into bundles to reduce the overall edge crossings. Our method uses a control mesh to guide the edgeclustering process; edge bundles can be 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. Users can further interact with the edgeclustering results through several advanced visualization techniques such as color and opacity enhancement. Compared with other edgeclustering methods, our approach is intuitive, flexible, and efficient. The experiments on some large graphs demonstrate the effectiveness of our method.
Glimmer: Multilevel MDS on the GPU
"... Abstract — We present Glimmer, a new multilevel algorithm for multidimensional scaling designed to exploit modern graphics processing unit (GPU) hardware. We also present GPUSF, a parallel, forcebased subsystem used by Glimmer. Glimmer organizes input into a hierarchy of levels and recursively app ..."
Abstract

Cited by 17 (3 self)
 Add to MetaCart
Abstract — We present Glimmer, a new multilevel algorithm for multidimensional scaling designed to exploit modern graphics processing unit (GPU) hardware. We also present GPUSF, a parallel, forcebased subsystem used by Glimmer. Glimmer organizes input into a hierarchy of levels and recursively applies GPUSF to combine and refine the levels. The multilevel nature of the algorithm makes local minima less likely while the GPU parallelism improves speed of computation. We propose a robust termination condition for GPUSF based on a filtered approximation of the normalized stress function. We demonstrate the benefits of Glimmer in terms of speed, normalized stress, and visual quality against several previous algorithms for a range of synthetic and real benchmark datasets. We also show that the performance of Glimmer on GPUs is substantially faster than a CPU implementation of the same algorithm. Index Terms — Multidimensional scaling, multilevel algorithms, optimization, GPGPU.
Towards utilizing GPUs in information visualization: A model and implementation of imagespace operations
 IEEE TVCG
, 2009
"... Modern programmable GPUs represent a vast potential in terms of performance and visual flexibility for information visualization research, but surprisingly few applications even begin to utilize this potential. In this paper, we conjecture that this may be due to the mismatch between the highlevel ..."
Abstract

Cited by 6 (2 self)
 Add to MetaCart
Modern programmable GPUs represent a vast potential in terms of performance and visual flexibility for information visualization research, but surprisingly few applications even begin to utilize this potential. In this paper, we conjecture that this may be due to the mismatch between the highlevel abstract data types commonly visualized in our field, and the lowlevel floatingpoint model supported by current GPU shader languages. To help remedy this situation, we present a refinement of the traditional information visualization pipeline that is amenable to implementation using GPU shaders. The refinement consists of a final imagespace step in the pipeline where the multivariate data of the visualization is sampled in the resolution of the current view. To concretize the theoretical aspects of this work, we also present a visual programming environment for constructing visualization shaders using a simple draganddrop interface. Finally, we give some examples of the use of shaders for wellknown visualization techniques.
Rapid Graph Layout Using Space Filling Curves
 IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS
, 2008
"... Network data frequently arises in a wide variety of fields, and nodelink diagrams are a very natural and intuitive representation of such data. In order for a nodelink diagram to be effective, the nodes must be arranged well on the screen. While many graph layout algorithms exist for this purpose ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
Network data frequently arises in a wide variety of fields, and nodelink diagrams are a very natural and intuitive representation of such data. In order for a nodelink diagram to be effective, the nodes must be arranged well on the screen. While many graph layout algorithms exist for this purpose, they often have limitations such as high computational complexity or node colocation. This paper proposes a new approach to graph layout through the use of space filling curves which is very fast and guarantees that there will be no nodes that are colocated. The resulting layout is also aesthetic and satisfies several criteria for graph layout effectiveness.
TwoPhase Mapping for Projecting Massive Data Sets
, 2010
"... Most multidimensional projection techniques rely on distance (dissimilarity) information between data instances to embed highdimensional data into a visual space. When data are endowed with Cartesian coordinates, an extra computational effort is necessary to compute the needed distances, making m ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
Most multidimensional projection techniques rely on distance (dissimilarity) information between data instances to embed highdimensional data into a visual space. When data are endowed with Cartesian coordinates, an extra computational effort is necessary to compute the needed distances, making multidimensional projection prohibitive in applications dealing with interactivity and massive data. The novel multidimensional projection technique proposed in this work, called PartLinear Multidimensional Projection (PLMP), has been tailored to handle multivariate data represented in Cartesian highdimensional spaces, requiring only distance information between pairs of representative samples. This characteristic renders PLMP faster than previous methods when processing large data sets while still being competitive in terms of precision. Moreover, knowing the range of variation for data instances in the highdimensional space, we can make PLMP a truly streaming data projection technique, a trait absent in previous methods.
Efficient Fault Simulation on ManyCore Processors
"... Fault simulation is essential in test generation, design for test and reliability assessment of integrated circuits. Reliability analysis and the simulation of selftest structures are particularly computationally expensive as a large number of patterns has to be evaluated. In this work, we propose ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
Fault simulation is essential in test generation, design for test and reliability assessment of integrated circuits. Reliability analysis and the simulation of selftest structures are particularly computationally expensive as a large number of patterns has to be evaluated. In this work, we propose to map a fault simulation algorithm based on the parallelpattern singlefault propagation (PPSFP) paradigm to manycore architectures and describe the involved algorithmic optimizations. Manycore architectures are characterized by a high number of simple execution units with small local memory. The proposed fault simulation algorithm exploits the parallelism of these architectures by use of parallel data structures. The algorithm is implemented for the NVIDIA GT200 Graphics Processing Unit (GPU) architecture and achieves a speedup of up to 17x compared to an existing GPU faultsimulation algorithm and up to 16x compared to stateoftheart algorithms on conventional processor architectures.
FeatureBased Graph Visualization
, 2008
"... A graph consists of a set and a binary relation on that set. Each element of the set is a node of the graph, while each element of the binary relation is an edge of the graph that encodes a relationship between two nodes. Graph are pervasive in many areas of science, engineering, and the social scie ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
A graph consists of a set and a binary relation on that set. Each element of the set is a node of the graph, while each element of the binary relation is an edge of the graph that encodes a relationship between two nodes. Graph are pervasive in many areas of science, engineering, and the social sciences: servers on the Internet are connected, proteins interact in large biological systems, social networks encode the relationships between people, and functions call each other in a program. In these domains, the graphs can become very large, consisting of hundreds of thousands of nodes and millions of edges. Graph drawing approaches endeavour to place these nodes in two or threedimensional space with the intention of fostering an understanding of the binary relation by a human being examining the image. However, many of these approaches to drawing do not exploit higherlevel structures in the graph beyond the nodes and edges. Frequently, these structures can be exploited for drawing. As an example, consider a large computer network where nodes are servers and edges are connections between those servers. If a user would like understand how servers at UBC connect to the rest of the network, a drawing that accentuates the set of nodes representing those servers may be more helpful than an approach where all nodes are drawn in the same way. In a featurebased approach, features are subgraphs exploited for the purposes of drawing. We endeavour to depict not only the binary relation, but the highlevel relationships between features. This thesis extensively explores a featurebased approach to graph visualization and demonstrates the viability of tools that aid in the visualization of large graphs. Our contributions lie in presenting and evaluating novel techniques and algorithms for graph visualization. We implement five systems in order to empirically evaluate these techniques and algorithms, comparing them to previous approaches.
Uncluttering Graph Layouts Using Anisotropic Diffusion and Mass Transport
"... Many graph layouts include very dense areas, making the layout difficult to understand. In this paper, we propose a technique for modifying an existing layout in order to reduce the clutter in dense areas. A physicallyinspired evolution process, based on a modified heat equation is used to create ..."
Abstract
 Add to MetaCart
Many graph layouts include very dense areas, making the layout difficult to understand. In this paper, we propose a technique for modifying an existing layout in order to reduce the clutter in dense areas. A physicallyinspired evolution process, based on a modified heat equation is used to create an improved layout density image, making better use of available screen space. Using results from optimal mass transport problems, a warp to the improved density image is computed. The graph nodes are displaced according to the warp. The warp maintains the overall structure of the graph, thus limiting disturbances to the mental map, while reducing the clutter in dense areas of the layout. The complexity of the algorithm depends mainly on the resolution of the image visualizing the graph and is linear in the size of the graph. This allows scaling the computation according to required running times. It is demonstrated how the algorithm can be significantly accelerated using a graphics processing unit (GPU), resulting in the ability to handle large graphs in a matter of seconds. Results on several layout algorithms and applications are demonstrated.