Convexity-Increasing Morphs of Planar Graphs

We study the problem of convexifying drawings of planar graphs. Given any planar straight-line drawing of an internally 3-connected graph, we show how to morph the drawing to one with strictly convex faces while maintaining planarity at all times. Our morph is convexity-increasing, meaning that once an angle is convex, it remains convex. We give an efficient algorithm that constructs such a morph as a composition of a linear number of steps where each step either moves vertices along horizontal lines or moves vertices along vertical lines. Moreover, we show that a linear number of steps is worst-case optimal. To obtain our result, we use a well-known technique by Hong and Nagamochi for finding redrawings with convex faces while preserving y-coordinates. Using a variant of Tutte's graph drawing algorithm, we obtain a new proof of Hong and Nagamochi's result which comes with a better running time. This is of independent interest, as Hong and Nagamochi's technique serves as a building block in existing morphing algorithms.Comment: Preliminary version in Proc. WG 201

A New Tool for Rectangular Dualization

OcORD is a software tool for rectangular dualization. Rectangular dualization is a dual representation of a plane graph introduced in the early seventies. It proved to be effective in applications such as architectural space planning and VLSI floorplanning. However, not all plane graphs admit a rectangular dual, which imposes severe limitations on its use in other applications. OcORD aims at freeing rectangular dualization from such restrictions and proving its effectiveness in graph visualization. This is achieved in two ways. Firstly, OcORD features a new linear-time algorithm creating a rectangular dual of any plane graph. Secondly, it shows how nice drawings of a graph can be easily obtained from its rectangular dual. Finally, the automatic generation of a Virtual World through rectangular dualization is described. [DOI: 10.1685/CSC09301] About DO

Visualization of graphs and trees for software analysis

A software architecture is an abstraction of a software system, which is indispensable for many software engineering tasks. Unfortunately, in many cases information pertaining to the software architecture is not available, outdated, or inappropriate for the task at hand. The RECONSTRUCTOR project focuses on software architecture reconstruction, i.e., obtaining architectural information from an existing system. Our research, which is part of RECONSTRUCTOR, focuses on interactive visualization and tries to answer the following question: How can users be enabled to understand the large amounts of information relevant for program understanding using visual representations? To answer this question, we have iteratively developed a number of techniques for visualizing software systems. A large number of these cases consists of hierarchically organized data, combined with adjacency relations. Examples are function calls within a hierarchically organized software system and correspondence relations between two different versions of a hierarchically organized software system. Hierarchical Edge Bundles (HEBs) are used to visualize adjacency relations in hierarchically organized data, such as the aforementioned function calls within a software system. HEBs significantly reduce visual clutter by visually bundling relations together. Massive Sequence Views (MSVs) are used in conjunction with HEBs to enable analysis of sequences of relations, such as function-call traces. HEBs are furthermore used to visually compare hierarchically organized data, e.g., two different versions of a software system. HEBs visually emphasize splits, joins, and relocations of subhierarchies and provide for interactive selection of sets of relations. Since HEBs require a hierarchy to perform the bundling, we present Force-Directed Edge Bundles (FDEBs) as an alternative to visually bundle relations together in the absence of a hierarchical component. FDEBs use a self-organizing approach to bundling in which edges are modeled as flexible springs that can attract each other. As a result, visual clutter is reduced and high-level edge patterns are better visible. Finally, in all these methods, a clear depiction of the direction of edges is important. We have therefore performed a separate study in which we evaluated ten representations (including the standard arrow) for depicting directed edges in a controlled user study

A New Approach for Visualizing UML Class Diagrams

UML diagrams have become increasingly important in the engineering and reengineering processes for software systems. Of particular interest are UML class diagrams whose purpose is to display class hierarchies (generalizations), associations, aggregations, and compositions in one picture. The combination of hierarchical and non-hierarchical relations poses a special challenge to a graph layout tool. Existing layout tools treat hierarchical and non-hierarchical relations either alike or as separate tasks in a two-phase process as in, e.g., cite{See97}. We suggest a new approach for visualizing UML class diagrams leading to a balanced mixture of the following aesthetic criteria: Crossing minimization, bend minimization, uniform direction within each class hierarchy, no nesting of one class hierarchy within another, orthogonal layout, merging of multiple inheritance edges, and good edge labelling. We have realized our approach within the graph drawing library GoVisual. Experiments show the superiority to state-of-the-art and industrial standard layouts

A New Approach for Visualizing UML Class Diagrams

UML diagrams have become increasingly important in the engineering and reengineering processes for software systems. Of particular interest are UML class diagrams whose purpose is to display class hierarchies (generalizations), associations, aggregations, and compositions in one picture. The combination of hierarchical and non-hierarchical relations poses a special challenge to a graph layout tool. Existing layout tools treat hierarchical and non-hierarchical relations either alike or as separate tasks in a two-phase process as in, e.g., cite{See97}. We suggest a new approach for visualizing UML class diagrams leading to a balanced mixture of the following aesthetic criteria: Crossing minimization, bend minimization, uniform direction within each class hierarchy, no nesting of one class hierarchy within another, orthogonal layout, merging of multiple inheritance edges, and good edge labelling. We have realized our approach within the graph drawing library GoVisual. Experiments show the superiority to state-of-the-art and industrial standard layouts

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