Study and implementation of some tree drawing algorithms

Graph drawing deals with the geometric representation of graphs [1]. Data representation problems that require graph models can be better understood when visualized with appropriate graph drawings. The typical data structure for modeling hierarchical information is a tree whose vertices represent entities and whose edges correspond to relationships between entities. Algorithms for drawing trees are typically based on some graph-theoretic insight into the structure of the tree. It is characterized by the fact that in the drawings produced, the nodes at the same distance from the root are horizontally aligned [1]. This level-based approach can be used for both binary and general trees. Algorithms based on this approach involve some issues that lead to aesthetically wider than necessary drawings. I implemented “A Naïve Tree Drawing Algorithm” [2] as part of an independent study. This will serve as a basis and an introduction to this proposed thesis. In this thesis, we develop some tree drawing algorithms and a planarity drawing algorithm in terms of constructing a new pseudocode for each algorithm. Also, we focus on the theoretical graphic insight to the structure of the tree by building a drawing application for each algorithm. These applications provide an important view of the properties of drawing trees. In addition, these algorithms are implemented in a GUI (JEdit) that reflects an efficient aesthetic drawing. The input graph is checked to verify that it is a tree. The user sees an error message otherwise. These algorithms allow the user to select the root in an input tree. This leads to a better understanding of the algorithms. Most of these algorithms calculate the levels of the tree and the number of the nodes in each level. These algorithms are : the “Recursive Algorithm for Binary Trees” from [3], which has many steps, the “A Node-Positioning Algorithm for General Trees” from [4], the “Area-Efficient Order-Preserving Planar Straight-Line Drawings of Ordered Trees” from Section 3 of [5], and “Planarity Drawing Algorithm” from Section 2 of [6].Thesis (M.S.)Department of Computer ScienceGraph drawing basics and (GUI) for graph theory -- A naive tree drawing algorithm -- Recursive algorithm for binary trees -- A node positioning algorithm for general trees -- Area-efficient order-preserving planar straight-line drawings of ordered trees -- Planarity drawing algorithm

A space efficient clustered visualization of large graphs

This paper proposes a new technique for visualizing large graphs of several ten thousands of vertices and edges. To achieve the graph abstraction, a hierarchical clustered graph is extracted from a general large graph based on the community structures which are discovered in the graph. An enclosure geometrical partitioning algorithm is then applied to achieve the space optimization. For graph drawing, we technically use the combination of a spring-embbeder algorithm and circular drawings that archives the goal of optimization of display space and aesthetical niceness. We also discuss an associated interaction mechanism accompanied with the layout solution. Our interaction not only allows users to navigate hierarchically up and down through the entire clustered graph, but also provides a way to navigate multiple clusters concurrently. Animation is also implemented to preserve users' mental maps during the interaction. © 2007 IEEE

Morphing Planar Graph Drawings Optimally

We provide an algorithm for computing a planar morph between any two planar straight-line drawings of any $n$-vertex plane graph in $O(n)$ morphing steps, thus improving upon the previously best known $O(n^2)$ upper bound. Further, we prove that our algorithm is optimal, that is, we show that there exist two planar straight-line drawings $\Gamma_s$ and $\Gamma_t$ of an $n$-vertex plane graph $G$ such that any planar morph between $\Gamma_s$ and $\Gamma_t$ requires $\Omega(n)$ morphing steps

Optimal Morphs of Convex Drawings

We give an algorithm to compute a morph between any two convex drawings of the same plane graph. The morph preserves the convexity of the drawing at any time instant and moves each vertex along a piecewise linear curve with linear complexity. The linear bound is asymptotically optimal in the worst case.Comment: To appear in SoCG 201

A graph rewriting programming language for graph drawing

This paper describes Grrr, a prototype visual graph drawing tool. Previously there were no visual languages for programming graph drawing algorithms despite the inherently visual nature of the process. The languages which gave a diagrammatic view of graphs were not computationally complete and so could not be used to implement complex graph drawing algorithms. Hence current graph drawing tools are all text based. Recent developments in graph rewriting systems have produced computationally complete languages which give a visual view of graphs both whilst programming and during execution. Grrr, based on the Spider system, is a general purpose graph rewriting programming language which has now been extended in order to demonstrate the feasibility of visual graph drawing

Hierarchical Partial Planarity

In this paper we consider graphs whose edges are associated with a degree of {\em importance}, which may depend on the type of connections they represent or on how recently they appeared in the scene, in a streaming setting. The goal is to construct layouts of these graphs in which the readability of an edge is proportional to its importance, that is, more important edges have fewer crossings. We formalize this problem and study the case in which there exist three different degrees of importance. We give a polynomial-time testing algorithm when the graph induced by the two most important sets of edges is biconnected. We also discuss interesting relationships with other constrained-planarity problems.Comment: Conference version appeared in WG201

Information visualization for DNA microarray data analysis: A critical review

Graphical representation may provide effective means of making sense of the complexity and sheer volume of data produced by DNA microarray experiments that monitor the expression patterns of thousands of genes simultaneously. The ability to use ldquoabstractrdquo graphical representation to draw attention to areas of interest, and more in-depth visualizations to answer focused questions, would enable biologists to move from a large amount of data to particular records they are interested in, and therefore, gain deeper insights in understanding the microarray experiment results. This paper starts by providing some background knowledge of microarray experiments, and then, explains how graphical representation can be applied in general to this problem domain, followed by exploring the role of visualization in gene expression data analysis. Having set the problem scene, the paper then examines various multivariate data visualization techniques that have been applied to microarray data analysis. These techniques are critically reviewed so that the strengths and weaknesses of each technique can be tabulated. Finally, several key problem areas as well as possible solutions to them are discussed as being a source for future work