Due to their great performance in many challenges, Deep Learning (DL) techniques keep gaining popularity in many fields. They have been adapted to process graph data structures to solve various complicated tasks such as graph classification and edge prediction. Eventually, they reached the Graph Drawing (GD) task. This article is an extended version of the previously published(DNN)2and presents a framework to leverage DL techniques for graph drawing (DL4GD). We demonstrate how it is possible to train a Deep Learning model to extract features from a graph and project them into a graph layout. The method proposes to leverage efficient Convolutional Neural Networks, adapting them to graphs using Graph Convolutions. The graph layout projection is learned by optimizing a cost function that does not require any ground truth layout, as opposed to prior work. This paper also proposes an implementation and benchmark of the framework to study its sensitivity to certain deep learning-related conditions. As the field is novel, and many questions remain to be answered, we do not focus on finding the most optimal implementation of the method, but rather contribute toward a better understanding of the approach potential. More precisely, we study different learning strategies relative to the models training datasets. Finally, we discuss the main advantages and limitations of DL4GD.

Abstract The use and creation of machine‐learning‐based solutions to solve problems or reduce their computational costs are becoming increasingly widespread in many domains. Deep Learning plays a large part in this growth. However, it has drawbacks such as a lack of explainability and behaving as a black‐box model. During the last few years, Visual Analytics has provided several proposals to cope with these drawbacks, supporting the emerging eXplainable Deep Learning field. This survey aims to (i) systematically report the contributions of Visual Analytics for eXplainable Deep Learning; (ii) spot gaps and challenges; (iii) serve as an anthology of visual analytical solutions ready to be exploited and put into operation by the Deep Learning community (architects, trainers and end users) and (iv) prove the degree of maturity, ease of integration and results for specific domains. The survey concludes by identifying future research challenges and bridging activities that are helpful to strengthen the role of Visual Analytics as effective support for eXplainable Deep Learning and to foster the adoption of Visual Analytics solutions in the eXplainable Deep Learning community. An interactive explorable version of this survey is available online at https://aware‐diag‐sapienza.github.io/VA4XDL .

Abstract Edge‐Path bundling is a recent edge bundling approach that does not incur ambiguities caused by bundling disconnected edges together. Although the approach produces less ambiguous bundlings, it suffers from high computational cost. In this paper, we present a new Edge‐Path bundling approach that increases the computational speed of the algorithm without reducing the quality of the bundling. First, we demonstrate that biconnected components can be processed separately in an Edge‐Path bundling of a graph without changing the result. Then, we present a new edge bundling algorithm that is based on observing and exploiting a strong relationship between Edge‐Path bundling and graph spanners. Although the worst case complexity of the approach is the same as of the original Edge‐Path bundling algorithm, we conduct experiments to demonstrate that the new approach is 5–256 times faster than Edge‐Path bundling depending on the dataset, which brings its practical running time more in line with traditional edge bundling algorithms.

Current deep learning approaches are cutting-edge methods for solving classification tasks. Arising transfer learning techniques allows applying large generic model to simple tasks whereas simpler models could be used. Large models raise the major problem of their memory consumption and processor usage and lead to a prohibitive ecological footprint. In that paper, we present a novel visual analytics approach to interactively prune those networks and thus limit that issue. Our technique leverages a novel sparkline matrix visualization technique as well as a novel local metric which evaluates the discriminatory power of a filter to guide the pruning process and make it interpretable. We assess the well- founded of our approach through two realistic case studies and a user study. For both of them, the interactive refinement of the model led to a significantly smaller model having similar prediction accuracy than the original one.

Projecting a set of$n$points on a grid of size$\sqrt{n}\times\sqrt{n}$provides the best possible information density in two dimensions without overlap. We leverage the Voronoi Relaxation method to devise a novel and versatile post-processing algorithm called VRGrid: it enables the arrangement of any 2D data on a grid while preserving its initial positions. We apply VRGrid to generate compact and overlap-free visualization of popular and overlap-prone projection methods (e.g., t-SNE). We prove that our method complexity is$O(\sqrt{n}.i.n.log(n))$, with i a determined maximum number of iterations and$n$the input dataset size. It is thus usable for visualization of several thousands of points. We evaluate VRGrid's efficiency with several metrics: distance preservation (DP), neighborhood preservation (NP), pairwise relative positioning preservation (RPP) and global positioning preservation (GPP). We benchmark VRGrid against two state-of-the-art methods: Self-Sorting Maps (SSM) and Distance-preserving Grid (DGrid). VRGrid outperforms these two methods, given enough iterations, on DP, RPP and GPP which we identify to be the key metrics to preserve the positions of the original set of points.

Current machine learning and deep learning approaches are cutting-edge methods for solving classification tasks. Comparing the performances of classification models has become a prominent task since the outbreak of these techniques. The performance of such classification models is measured by the ratio between the correctly predicted samples and the others. The most widely used visualization to represent this information is the Confusion matrix. Yet, if this technique is suited to apprehend one model performances, very few works use this representation to compare models. In that paper, we present the Relative Confusion Matrix (RCM), a new matrix visualization that leverages Confusion matrices and a color encoding to expose the class-wise differences of performances between two models. We conduct a user evaluation to compare RCM with two confusion matrix variants. Our results show that RCM encoding leads to a more efficient comparison of two models than existing approaches.

Edge bundling techniques cluster edges with similar attributes (i.e. similarity in direction and proximity) together to reduce the visual clutter. All edge bundling techniques to date implicitly or explicitly cluster groups of individual edges, or parts of them, together based on these attributes. These clusters can result in ambiguous connections that do not exist in the data. Confluent drawings of networks do not have these ambiguities, but require the layout to be computed as part of the bundling process. We devise a new bundling method, Edge-Path bundling, to simplify edge clutter while greatly reducing ambiguities compared to previous bundling techniques. Edge-Path bundling takes a layout as input and clusters each edge along a weighted, shortest path to limit its deviation from a straight line. Edge-Path bundling does not incur independent edge ambiguities typically seen in all edge bundling methods, and the level of bundling can be tuned through shortest path distances, Euclidean distances, and combinations of the two. Also, directed edge bundling naturally emerges from the model. Through metric evaluations, we demonstrate the advantages of Edge-Path bundling over other techniques.

The design of efficient representations is well established as a fruitful way to explore and analyze complex or large data. In these representations, data are encoded with various visual attributes depending on the needs of the representation itself. To make coherent design choices about visual attributes, the visual search field proposes guidelines based on the human brain’s perception of features. However, information visualization representations frequently need to depict more data than the amount these guidelines have been validated on. Since, the information visualization community has extended these guidelines to a wider parameter space. This paper contributes to this theme by extending visual search theories to an information visualization context. We consider a visual search task where subjects are asked to find an unknown outlier in a grid of randomly laid out distractors. Stimuli are defined by color and shape features for the purpose of visually encoding categorical data. The experimental protocol is made of a parameters space reduction step (i.e., sub-sampling) based on a machine learning model, and a user evaluation to validate hypotheses and measure capacity limits. The results show that the major difficulty factor is the number of visual attributes that are used to encode the outlier. When redundantly encoded, the display heterogeneity has no effect on the task. When encoded with one attribute, the difficulty depends on that attribute heterogeneity until its capacity limit (7 for color, 5 for shape) is reached. Finally, when encoded with two attributes simultaneously, performances drop drastically even with minor heterogeneity.

In information visualization, it has become mandatory to assess visualization techniques efficiency either to write a survey, optimize a technique or even design a new one. To do so, the common way is to conduct user evaluations through which human subjects are asked to solve a task on different visualization techniques while their performances are measured to assess which technique is the most efficient. These evaluations can be complex to design and setup in order not to be biased and, in the end, their results can become contestable when the evaluation methods standards evolve. To overcome these flaws, new evaluation methods are emerging, mostly making use of modern and efficient computer vision techniques such as deep learning. These new methods rely on a strong assumption that has not been studied deeply enough yet: humans and deep learning models performances can be correlated. This paper explores the performances of both a state-of-the-art deep neural network and human subjects on an outlier detection task taken from a previous experiment of the literature. The objective is to study whether the machine and humans behaviors were different or if some correlations can be observed. Our study shows that their results are significantly correlated and a machine learning model efficiently learned to predict human performances using deep neural network metrics as input. Hence, this work presents a use case where using a deep neural network to assess human subjects performances is efficient.

The size of available graphs has drastically increased in recent years. The real-time visualization of graphs with millions of edges is a challenge but is necessary to grasp information hidden in huge datasets. This article presents an end-to-end technique to visualize huge graphs using an established Big Data ecosystem and a lightweight client running in a Web browser. For that purpose, levels of abstraction and graph tiles are generated by a batch layer and the interactive visualization is provided using a serving layer and client-side real-time computation of edge bundling and graph splatting. A major challenge is to create techniques that work without moving data to an ad hoc system and that take advantage of the horizontal scalability of these infrastructures. We introduce two novel scalable algorithms that enable to generate a canopy clustering and to aggregate graph edges. These two algorithms are both used to produce levels of abstraction and graph tiles. We prove that our technique guarantee a quality of visualization by controlling both the necessary bandwidth required for data transfer and the quality of the produced visualization. Furthermore, we demonstrate the usability of our technique by providing a complete prototype. We present benchmarks on graphs with millions of elements and we compare our results to those obtained by state of the art techniques. Our results show that new Big Data technologies can be incorporated into visualization pipeline to push out the size limits of graphs one can visually analyze.

Many end-user evaluations of data visualization techniques have been run during the last decades. Their results are cornerstones to build efficient visualization systems. However, designing such an evaluation is always complex and time-consuming and may end in a lack of statistical evidence and reproducibility. We believe that modern and efficient computer vision techniques, such as deep convolutional neural networks (CNNs), may help visualization researchers to build and/or adjust their evaluation hypothesis. The basis of our idea is to train machine learning models on several visualization techniques to solve a specific task. Our assumption is that it is possible to compare the efficiency of visualization techniques based on the performance of their corresponding model. As current machine learning models are not able to strictly reflect human capabilities, including their imperfections, such results should be interpreted with caution. However, we think that using machine learning-based pre-evaluation, as a pre-process of standard user evaluations, should help researchers to perform a more exhaustive study of their design space. Thus, it should improve their final user evaluation by providing it better test cases. In this paper, we present the results of two experiments we have conducted to assess how correlated the performance of users and computer vision techniques can be. That study compares two mainstream graph visualization techniques: node-link (NL) and adjacency-matrix (AM) diagrams. Using two well-known deep convolutional neural networks, we partially reproduced user evaluations from Ghoniem et al. and from Okoe et al.. These experiments showed that some user evaluation results can be reproduced automatically.

In the context of multiple views, coordination is essential to navigate and grasp the relationships lying behind the different juxtaposed views. Linked highlighting is a typical example of coordination where a subset of the data points is emphasized simultaneously on all views. The strength of this approach is that the selected data can be studied within its context. Other approaches have been used to implement coordination such as using varying levels of transparency or visual links. We propose to use spatial distortion to contribute a similar effect in multiple views. It is particularly suited to the context of multiple views since it alleviates the lack of screen space by reallocating it based on a certain definition of user interest. The proposed method targets coordination between views that represent the same entities and readily adapts to various visualization forms. It is based on a user degree-of-interest function, defined on these entities, that acts as a common ground for the distortion of all views. Views are distorted such that empty areas and areas holding entities of lesser interest are compressed to the benefit of areas holding entities of higher interest. To demonstrate its feasibility and versatility, we describe how to technically apply our approach to several common visualization techniques.

Heatmap visualization is a well-known type of visualization to alleviate the overplot problem of point visualization. As such, it is well suited to visualize Big Data. In order to tackle the velocity problem of Big Data, one has to leverage streaming computations. Recently, canopy clustering was shown to be well suited for Big Data heatmap visualization. In this article, we present how to design a streaming algorithm to compute canopy clustering using Apache Spark. This result is directly applicable to be included into a lambda architecture.

This paper presents a novel way to draw very large graphs, especially those too big to fit the memory of a single computer. This new method takes advantage of the recent progress in distributed computing, notably using the Apache MapReduce library called Spark. Our implementation of a force-directed graph drawing algorithm and the way to compute repulsive forces in MapReduce are exhibited. We demonstrate the horizontal scalability of this algorithm and show layouts computed on a Hadoop cluster with our method.

The rise of Big Data and powerful mobile devices calls for libraries able to render a large number of visual elements and make fast animations without loss of frame rate. We introduce the FATuM library as a middleware for visualization. With a single abstraction for visual elements based on the work of Bertin and adaptation of the double buffering technique, we enable animated visualization of large datasets in native applications and in the browser using the same codebase. Our system does not differentiate animated from static rendering, thus reducing code complexity and guaranteeing smooth animation. We show that our system maintains 60fps for up to 200.000 visual elements in a native application and 30fps for 100.000 visual elements in a web browser.

Visualization of hierarchical weighted and directed graphs are usually done with node-link or adjacency matrix diagrams. However, these representations suffer from various drawbacks: low readability in a context of Big Data, high number of edge crossings, difficulty to efficiently represent the weighting. With the stated goal of reducing these drawbacks, we designed Adjasankey, a hybrid visual representation of weighted and directed graphs using hierarchical abstractions. This technique combines adjacency matrices readability of large graphs and flow diagrams visual design efficiency for weighting depiction. Associated to Big Data computing and light-weight web rendering, our tool allows to depict and interact in real time on huge dataset and supports user multi-scale exploration and analysis. To show the efficiency of Adjasankey, we present a case study on the analysis of a Customer to Customer website.

The emergence of very large hierarchies that result from the increase in available data raises many problems of visualization and navigation. On data sets of such scale, classical graph drawing methods do not take advantage of certain human cognitive skills such as shape recognition. These cognitive skills could make it easier to remember the global structure of the data. In this paper, we propose a method that is based on the use of nested irregular shapes. We name it GosperMap as we rely on the use of a Gosper Curve to generate these shapes. By employing human perception mechanisms that were developed by handling, for example, cartographic maps, this technique facilitates the visualization and navigation of a hierarchy. An algorithm has been designed to preserve region containment according to the hierarchy and to set the leaves' sizes proportionally to a property, in such a way that the size of nonleaf regions corresponds to the sum of their children's sizes. Moreover, the input ordering of the hierarchy's nodes is preserved, i.e., the areas that represent two consecutive children of a node in the hierarchy are adjacent to one another. This property is especially useful because it guarantees some stability in our algorithm. We illustrate our technique by providing visualization examples of the repartition of tax money in the US over time. Furthermore, we validate the use of the GosperMap in a professional documentation context and show the stability and ease of memorization for this type of map.

Technological advances in biology lead to a profusion of quantitative data, raising analytical challenges. Visual analytics is particularly well suited to address these difficulties. It helps to interactively move through the different levels of analysis and to simultaneously investigate data with different point of views. It is especially the case when dealing with biological networks that can contain hundreds of elements. In these studies biologists generally follow the same analytic process which consists in first getting an overview of the data before focussing on a few relevant subnetworks. In this article we present, Systrip, a visual environment for the analysis of time-series data in the context of biological networks. In particular we focus on the study of metabolism. Systrip gathers bioinformatics and graph theoretical algorithms that can be assembled in different ways to help biologists in their visual mining process. This framework had been used to analyse various real biological data. In this article we describe how it helped in understanding drug effects on the metabolism of the parasite of the tsetse fly causing sleeping sickness.

Abstract PrEd [ Ber00 ] is a force‐directed algorithm that improves the existing layout of a graph while preserving its edge crossing properties. The algorithm has a number of applications including: improving the layouts of planar graph drawing algorithms, interacting with a graph layout, and drawing Euler‐like diagrams. The algorithm ensures that nodes do not cross edges during its execution. However, PrEd can be computationally expensive and overly‐restrictive in terms of node movement. In this paper, we introduce ImPrEd: an improved version of PrEd that overcomes some of its limitations and widens its range of applicability. ImPrEd also adds features such as flexible or crossable edges, allowing for greater control over the output. Flexible edges, in particular, can improve the distribution of graph elements and the angular resolution of the input graph. They can also be used to generate Euler diagrams with smooth boundaries. As flexible edges increase data set size, we experience an execution/drawing quality trade off. However, when flexible edges are not used, ImPrEdproves to be consistently faster than PrEd.

Many graph visualization systems use graph hierarchies to organize a large input graph into logical components. These approaches detect features globally in the data and place these features inside levels of a hierarchy. However, this feature detection is a global process and does not consider nodes of the graph near a feature of interest. TugGraph is a system for exploring paths and proximity around nodes and subgraphs in a graph. The approach modifies a pre-existing hierarchy in order to see how a node or subgraph of interest extends out into the larger graph. It is guaranteed to create path-preserving hierarchies, so that the abstraction shown is meaningful with respect to the underlying structure of the graph. The system works well on graphs of hundreds of thousands of nodes and millions of edges. TugGraph is able to present views of this proximal information in the context of the entire graph in seconds, and does not require a layout of the full graph as input.

The first step of any information visualization system is to enable end user to import their dataset into the system. However, non expert user are faced to the difficult task of choosing how their data should/could be transform to be used in these Infovis systems. In that paper we address the case where end users want to use dataset in tabular format. We propose a novel method for automatic graph generation from these datasets. That method consists in first building taxonomy of dimensions. Then, that taxonomy is used to provide to user a system that enables to interactively navigate into the set of possible data transformation.

This paper describes an approach exploiting the full capabilities of GPU's to enhance the usability of edge bundling in real applications. Edge bundling, as well as other edge clustering approaches relying on the use of high quality edge rerouting. Typical approach for drawing edge-bundled graph is to render edges as curves. But curves generation can have a relatively high computational costs and do not easily comply with real-time interaction. Furthermore, while edge bundling provides a much better overall readability of a graph, the bundles make it more difficult to recover local information. Our goal was thus to provide fluid interaction allowing the recovery of local information through specific interaction techniques. The system we built offers folklore or classical interaction such as zoom & pan, fish-eye and magnifying lens. We also implemented the Bring & Go technique by Tominski et al. We proposed an approach exploiting the full computing power of GPU's when rendering graph edges as parametric splines. The gain in efficiency when running all curves computations on the GPU turns bundling techniques into techniques that can be embedded in interactive systems concerned with graphs of several thousands of nodes and edges.

Visualization of graphs containing many nodes and edges efficiently is quite challenging since representations generally suffer from visual clutter induced by the large amount of edge crossings and node-edge overlaps. That problem becomes even more important when nodes positions are fixed, such as in geography were nodes positions are set according to geographical coordinates. Edge bundling techniques can help to solve this issue by visually merging edges along common routes but it can also help to reveal high-level edge patterns in the network and therefore to understand its overall organization. In this paper, we present a generalization of [18] to reduce the clutter in a 3D representation by routing edges into bundles as well as a GPU-based rendering method to emphasize bundles densities while preserving edge color. To visualize geographical networks in the context of the globe, we also provide a new technique allowing to bundle edges around and not across it.

Abstract Visualizing graphs containing many nodes and edges efficiently is quite challenging. Drawings of such graphs generally suffer from visual clutter induced by the large amount of edges and their crossings. Consequently it is difficult to read the relationships between nodes and the high‐level edge patterns that may exist in standard node‐link diagram representations. Edge bundling techniques have been proposed to help solve this issue, which rely on high quality edge rerouting. In this paper, we introduce an intuitive edge bundling technique which efficiently reduces edge clutter in graphs drawings. Our method is based on the use of a grid built using the original graph to compute the edge rerouting. In comparison with previously proposed edge bundling methods, our technique improves both the level of clutter reduction and the computation performance. The second contribution of this paper is a GPU‐based rendering method which helps users perceive bundles densities while preserving edge color.

Many graph visualization systems use graph hierarchies to organize a large input graph into logical components. These approaches detect features globally in the data and place these features inside levels of a hierarchy. However, this feature detection is a global process and does not consider nodes of the graph near a feature of interest. TugGraph is a system for exploring paths and proximity around nodes and subgraphs in a graph. The approach modifies a pre-existing hierarchy in order to see how a node or subgraph of interest extends out into the larger graph. It is guaranteed to create path-preserving hierarchies, so that the abstraction shown is meaningful with respect to the structure of the graph. The system works well on graphs of hundreds of thousands of nodes and millions of edges. TugGraph is able to present views of this proximal information in the context of the entire graph in seconds, and does not require a layout of the full graph as input.

In this paper, we present an algorithm to lay out a particular class of graphs coming from real case studies: the quasi-tree graph class. Protein and internet mappings projects have shown the interest of devicing dedicated tools for visualizing such graphs. Our method addresses a challenging problem which consists in computing a layout of large graphs (up to hundred of thousands of nodes) that emphasizes their tree-like property in an efficient time. In order to validate our approach, we compare our results on real data to those obtained by well known algorithms.

Most methods for generating Euler diagrams describe the detection of the general structure of the final drawing as the first step. This information is generally encoded using a graph, where nodes are the regions to be represented and edges represent adjacency. A planar drawing of this graph will then indicate how to draw the sets in order to depict all the set intersections. In this paper we present an heuristic to construct this structure, the intersection graph. The final Euler diagram can be constructed by drawing the sets boundaries around the nodes of the intersection graph, either manually or automatically.

Abstract Visualisation of taxonomies and sets has recently become an active area of research. Many application fields now require more than a strict classification of elements into a hierarchy tree. Euler diagrams, one of the most natural ways of depicting intersecting sets, may provide a solution to these problems. In this paper, we present an approach for the automatic generation of Euler‐like diagrams. This algorithm differs from previous approaches in that it has no undrawable instances of input, allowing it to be used in systems where the output is always required. We also improve the readability of Euler diagrams through the use of Bézier curves and transparent coloured textures. Our approach has been implemented using the Tulip platform. Both the source and executable program used to generate the results are freely available.

Given a group of overlapping sets, it is not always possible to represent it with Euler diagrams. Euler diagram characteristics might collide with the sets relationships to depict, making it impossible to outline a correct draw. In order to be able to show a greater class of instances, Euler diagrams have been extended allowing more general patterns, but so far all the most common definitions cannot represent all the possible connection between sets.We aim to introduce methods and constructions to produce a clear representation, as close as possible to Euler diagrams, even for sets that are not formally drawable in that way. We investigate on the reasons that make a diagram undrawable, in order to evaluate how and when to apply the mentioned structures, and to give the foundations necessary to design algorithms for this purpose.

Abstract Understanding detailed changes done to source code is of great importance in software maintenance. We present Code Flows, a method to visualize the evolution of source code geared to the understanding of fine and mid‐level scale changes across several file versions. We enhance an existing visual metaphor to depict software structure changes with techniques that emphasize both following unchanged code as well as detecting and highlighting important events such as code drift, splits, merges, insertions and deletions. The method is illustrated with the analysis of a real‐world C++ code system.

Several previous systems allow users to interactively explore a large input graph through cuts of a superimposed hierarchy. This hierarchy is often created using clustering algorithms or topological features present in the graph. However, many graphs have domain-specific attributes associated with the nodes and edges, which could be used to create many possible hierarchies providing unique views of the input graph. GrouseFlocks is a system for the exploration of this graph hierarchy space. By allowing users to see several different possible hierarchies on the same graph, the system helps users investigate graph hierarchy space instead of a single fixed hierarchy. GrouseFlocks provides a simple set of operations so that users can create and modify their graph hierarchies based on selections. These selections can be made manually or based on patterns in the attribute data provided with the graph. It provides feedback to the user within seconds, allowing interactive exploration of this space.

This paper introduces a new technique easing the navigation and interactive exploration of huge multidimensional datasets. Following the pixel-oriented paradigm [8], the key ingredients enabling the interactive navigation of extreme volumes of data rely on a set of functions bijectively mapping data elements to screen pixels. The use of the mapping from data elements to pixels constrain the computational complexity for the rendering process to be linear with respect to the number of rendered pixels on the screen as opposed to the dataset size. Our method furthermore allows the implementation of usual information visualization techniques such as zoom and pan, anamorphosis and texturing. As a proof-of-concept, we show how our technique can be adapted to interactively explore the Datacube, turning our approach into an efficient system for visual datamining. We report experiments conducted on a Datacube containing 50 millions of items. To our knowledge, our technique outperforms all existing ones and push the scalability limit close to the billion of elements. Supporting all basic navigation techniques, and being moreover flexible makes it easily reusable for a large number of applications.

Visualization of clustered graphs has been a research area since many years. In this paper, we describe a new approach that can be used in real application where graph does not contain only topological information but also extrinsic parameters (i.e. user attributes on edges and nodes). In the case of force-directed algorithm, management of attributes corresponds to take into account edge weights. We propose an extension of the GRIP algorithm in order to manage edge weights. Furthermore, by using Voronoi diagram we constrained that algorithm to draw each cluster in a non overlapping convex region. Using these two extensions we obtained an algorithm that draw clustered weighted graphs. Experimentation has been done on data coming from biology where the network is the genes- proteins interaction graph and where the attributes are gene expression values from microarray experiments.

Grouse is a feature-based approach to steerable exploration of a graph and an associated hierarchy. Steerability allows exploration to begin immediately, rather than requiring a costly layout of the entire graph as an initial step. In a feature-based approach, the subgraph inside a metanode of the graph hierarchy is laid out with a well- chosen algorithm appropriate for its topological structure. Grouse preserves the input hierarchy, which provides meaningful information to the user when its metanodes correspond to features of interest. When a metanode in the hierarchy is opened, a limited number of metanodes are laid out again along the path between the opened node and the root. We demonstrate the effectiveness of Grouse on datasets from IMDB, the Internet Movie Database, where nodes are actors and cliques represent movies. The combination of feature-based layout and limited relayout computation does not fragment features in the hierarchy and improves the number of levels in the hierarchy that can be seen at once over previous approaches.

We describe TopoLayout, a feature-based, multilevel algorithm that draws undirected graphs based on the topological features they contain. Topological features are detected recursively inside the graph, and their subgraphs are collapsed into single nodes, forming a graph hierarchy. Each feature is drawn with an algorithm tuned for its topology. As would be expected from a feature-based approach, the runtime and visual quality of TopoLayout depends on the number and types of topological features present in the graph. We show experimental results comparing speed and visual quality for TopoLayout against four other multilevel algorithms on a variety of data sets with a range of connectivities and sizes. TopoLayout frequently improves the results in terms of speed and visual quality on these data sets.

In this paper we describe NAVRNA, an interactive system that enables biologists or researchers in bioinformatics to visualize, explore and edit RNA molecules. The key characteristics of NAVRNA are (1) to exploit multiple display surfaces (2) to enable the manipulation of both the 2D view of RNA called secondary structure, as well as the 3D view of RNA called tertiary structure while maintaining consistency between the two views, (3) to enable co-located synchronous collaborative manipulation of the RNA structures and (4) to provide two-handed interaction techniques for navigating and editing RNA structures and in particular a two-handed technique for bending the structure.

Ribonucleic Acid (RNA) is an important molecule which performs a wide range of functions in biological systems. We present a method for visualizing, exploring and editing RNA molecules. The method relies on the visualization of the 3D tertiary structure of RNA as well as on the automatic extraction and visualization of the 2D secondary structure. The 2D representation is used to navigate in the tertiary structure. The method has been implemented in a multi-surface interactive system, NAVRNA, that allows collaborative analysis of RNA.

A metabolic network is a set of interconnected metabolic pathways (subnetworks). Until recently, metabolic studies were dedicated to a single pathway, but current researches now consider the entire network. As matter stands, existing visualization tools cannot be used to undertake these global studies since they have been designed to probe metabolic pathways. For the purpose of making it feasible, this paper presents a graph drawing algorithm for the whole metabolic network. Our collaboration with biologists led us to introduce drawing constraints which take into account the decomposition of the network into metabolic pathways as well as biochemical textbook drawing conventions. These constraints raise numerous graph drawing problems which are solved by first recursively decomposing the network then applying suitable graph drawing algorithms. Finally, we present an application that illustrates the advantage of this representation when visualizing groups of reactions which span several metabolic pathways.

Quasi-trees, namely graphs with tree-like structure, appear in many application domains, including bioinformatics and computer networks. Our new SPF approach exploits the structure of these graphs with a two-level approach to drawing, where the graph is decomposed into a tree of biconnected components. The low-level biconnected components are drawn with a force-directed approach that uses a spanning tree skeleton as a starting point for the layout. The higher-level structure of the graph is a true tree with meta-nodes of variable size that contain each biconnected component. That tree is drawn with a new area-aware variant of a tree drawing algorithm that handles high-degree nodes gracefully, at the cost of allowing edge-node overlaps. SPF performs an order of magnitude faster than the best previous approaches, while producing drawings of commensurate or improved quality.

Insight of multiscale networks could be accessed through the visualization of automatic multiscale clusterings. But results of these methods do not necessarily fulfill user expectations since they don't provide error prone clusterings. In this article we propose a way to refine interactively these results by the use of multiscale grouping and ungrouping interactions. This approach revealed to give very good results on common networks, especially on small world networks. Moreover, the linear algorithm makes that the method remains interactive on huge graphs with thousand of nodes.

UNLABELLED: ProViz is a tool for the visualization of protein-protein interaction networks, developed by the IntAct European project. It provides facilities for navigating in large graphs and exploring biologically relevant features, and adopts emerging standards such as GO and PSI-MI. AVAILABILITY: ProViz is available under the GPL and may be freely downloaded. Source code and binaries are available at http://cbi.labri.fr/eng/proviz.htm CONTACT: [email protected]

We propose a method for the visualization of large graphs. Our approach is based on the calculation of a density function resulting from the application of a metric on the vertices of a graph. The density function is then filtered using a convolution, leading to a partition of the graph. The choice of an appropriate kernel for the convolution makes it possible to control the number of clusters, and their size. Our algorithm can be executed automatically, but the parameters can also be interactively fixed by the user. We applied the algorithm to the problem of legacy code extraction from inclusion relation of C++ source files and film sequence analysis. The metric used here is defined from Strahler numbers, which measure the "ramification" level of graph vertices.