6 research outputs found
Graph Drawing via Gradient Descent,
Readability criteria, such as distance or neighborhood preservation, are
often used to optimize node-link representations of graphs to enable the
comprehension of the underlying data. With few exceptions, graph drawing
algorithms typically optimize one such criterion, usually at the expense of
others. We propose a layout approach, Graph Drawing via Gradient Descent,
, that can handle multiple readability criteria. can optimize
any criterion that can be described by a smooth function. If the criterion
cannot be captured by a smooth function, a non-smooth function for the
criterion is combined with another smooth function, or auto-differentiation
tools are used for the optimization. Our approach is flexible and can be used
to optimize several criteria that have already been considered earlier (e.g.,
obtaining ideal edge lengths, stress, neighborhood preservation) as well as
other criteria which have not yet been explicitly optimized in such fashion
(e.g., vertex resolution, angular resolution, aspect ratio). We provide
quantitative and qualitative evidence of the effectiveness of with
experimental data and a functional prototype:
\url{http://hdc.cs.arizona.edu/~mwli/graph-drawing/}.Comment: Appears in the Proceedings of the 28th International Symposium on
Graph Drawing and Network Visualization (GD 2020
Balanced Aspect Ratio Trees and Their Use for Drawing Very Large Graphs
We describe a new approach for cluster-based drawing of large graphs, which obtains clusters by using binary space partition (BSP) trees. We also introduce a novel BSP-type decomposition, called the balanced aspect ratio (BAR) tree, which guarantees that the cells produced are convex and have bounded aspect ratios. In addition, the tree depth is O(log n), and its construction takes O(n log n) time, where n is the number of points. We show that the BAR tree can be used to recursively divide a graph embedded in the plane into subgraphs of roughly equal size, such that the drawing of each subgraph has a balanced aspect ratio. As a result, we obtain a representation of a graph as a collection of O(log n) layers, where each succeeding layer represents the graph in an increasing level of detail. The overall running time of the algorithm is O(n log n+m+D0(G)), where n and m are the number of vertices and edges of the graph G, andD0(G) is the time it takes to obtain an initial embedding of G in the plane. In particular, if the graph is planar each layer is a graph drawn with straight lines and without crossings on the n×n grid and the running time reduces to O(n log n)
A Potential-Field-Based Multilevel Algorithm for Drawing Large Graphs
The aim of automatic graph drawing is to compute a well-readable layout of a given graph G=(V,E). One very popular class of algorithms for drawing general graphs are force-directed methods. These methods generate drawings of G in the plane so that each edge is represented by a straight line connecting its two adjacent nodes. The computation of the drawings is based on associating G with a physical model. Then, the algorithms iteratively try to find a placement of the nodes so that the total energy of the physical system is minimal. Several force-directed methods can visualize large graphs containing many thousands of vertices in reasonable time. However, only some of these methods guarantee a sub-quadratic running time in special cases or under certain assumptions, but not in general. The others are not sub-quadratic at all. We develop a new force-directed algorithm that is based on a combination of an efficient multilevel strategy and a method for approximating the repulsive forces in the system by rapidly evaluating potential fields. The worst-case running time of the new method is O(|V| log|V|+|E|) with linear memory requirements. In practice, the algorithm generates nice drawings of graphs containing up to 100000 nodes in less than five minutes. Furthermore, it clearly visualizes even the structures of those graphs that turned out to be challenging for other tested methods