Orthogonal Compaction Using Additional Bends

TL;DR

This paper introduces a one-dimensional orthogonal compaction algorithm that improves geometric results by allowing additional bends, reducing total edge length and drawing area.

Contribution

It presents a novel compaction method that alters edge shapes with extra bends to optimize layout size, a departure from traditional bend-preserving algorithms.

Findings

Reduced total edge length in orthogonal drawings

Decreased drawing area through shape alterations

Additional bends improve compactness

Abstract

Compacting orthogonal drawings is a challenging task. Usually algorithms try to compute drawings with small area or edge length while preserving the underlying orthogonal shape. We present a one-dimensional compaction algorithm that alters the orthogonal shape of edges for better geometric results. An experimental evaluation shows that we were able to reduce the total edge length and the drawing area, but at the expense of additional bends.

Equations

$$l(a)\le x(a)\le u(a)$$

$$\sum _{a=(k,l)}x(a)-\sum _{a=(j,k)}x(a)=b(k)$$

Full text

1 Introduction

The compaction problem in orthogonal graph drawing deals with constructing an area-efficient drawing on the orthogonal grid. Every edge is drawn as a sequence of horizonal and vertical segments, where the vertices and bends are placed on grid points. Compaction has been studied in the context of the topology-shape-metrics approach [3]. Here, in a first phase a combinatorial embedding is computed that determines the topology of the layout with the goal to minimize the number of crossings. In the second phase, a dimensionless orthogonal shape of the graph is determined by fixing the angles between adjacent edges and the bends along the edges. The goal is to minimize the number of bends. In the third phase, metrics are added to the orthogonal shape. In this context, first the coordinates of vertices and bends are assigned to grid points so that the given orthogonal shape is maintained. Finally, the (orthogonal) compaction problem asks for a drawing minimizing geometric aestetic criteria, such as the area of the drawing or the total edge length. The shape is not allowed to change.

Since the orthogonal compaction problem is NP-hard [16], in practice heuristics are used that fix the $x$- (or $y$-, resp.) coordinates and solve the resulting compaction problem in one dimension. Given an initial drawing, the one-dimensional compaction problem with the goal of minimizing the height (or width, resp.) of the layout can be transformed to the longest path problem in a directed acyclic graph. If in addition the total edge length shall be minimized, the problem can be solved by computing a minimum cost flow.

The topology-shape-metrics approach aims at drawings with a small number of crossings, a small number of bends, and a small drawing area. These goals are addressed in this order. And indeed, compared with other drawing methods, the number of crossings and bends is relatively small [8]. However, the layouts often contain large areas of white space. It seems that the goal of getting a small drawing area has not been achieved so far. Consider the drawing in Fig. 1(a) which contains large areas of white space due to shape restrictions. By introducing two bends on one of the edges the drawing area can be reduced drastically. This motivates us to study a compaction problem in which the shape conditions are relaxed.

This brings us back to the origin of the orthogonal compaction problem in VLSI-design (see, e.g., [15]). In contrast to the compaction problem considered in graph drawing, even the permutation of wires along the boundary of a component (and hence, changing the embedding) is allowed.

We suggest a moderate relaxation of the orthogonal compaction problem. More precisely, we suggest to study the one-dimensional monotone flexible edge compaction problem with fixed vertex star geometry, henceforth the Fled-Five compaction problem, which asks for the minimization of the vertical (horizontal, resp.) edge length and allows changing the orthogonal shape of the edge, but preserves the $x$-monotonicity ($y$-monotonicity, resp.) of edge segments and prohibits changing the directions of the initial edge segments around the vertices. We present a polynomial-time algorithm based on a network flow model that solves the Fled-Five compaction problem to optimality. Our computational results show that repeated application of Fled-Five compaction in $x$- and $y$-direction is able to reduce the total edge length and the drawing area at the expense of additional bends.

This paper is organized as follows. We recall the state of the art in Sect. 2 and some basic definition about orthogonal graph drawing and especially the compaction phase in Sect. 3. We present our new algorithm in Sect. 4 and evaluate it experimentally in Sect. 5.

2 State-of-the-Art

Patrignani [16] has shown that planar orthogonal compaction is in general NP-hard and Bannister et al. [2] gave inapproximability results for the nonplanar case. But for some special cases there exist polynomial algorithms, e.g. if all faces are of rectangular shape [7] or if all faces are so-called turn-regular [4] or have a unique completion [14]. Klau et al. [14] suggested a branch-and-cut approach to solve an integer linear program based on extending a pair of constraint graphs. However, in practice, heuristics are used which iteratively fix the $x$-, and then the $y$-coordinates, and solve the resulting one-dimensional compaction problem. This process is repeated until no further progress is made. One-dimensional compaction algorithms often use either network flow techniques or a longest path method in order to assign integer coordinates to the vertices, see e.g. [11] for an overview. An experimental comparison of planar compaction algorithms was presented by Klau et al. [13].

Although there has been done some work to improve the quality of a drawing by changing its shape, e.g. [9], most compaction algorithms take as input an orthogonal representation and try to produce compact drawings with respect to that representation. This can lead to an unnecessarily large drawing area with unused space. Often better results in terms of area and edge length can be achieved if the orthogonal shape can be altered, as we have seen in Fig. 1. On the other hand, it might be desirable to not change a given drawing too much in order to preserve the mental map.

3 Notation and Preliminary Results

In this section we give basic definitions and notations. For more details on orthogonal drawings and graph drawing in general see e.g. [7], [11] or [17].

3.1 Orthogonal Graph Drawing

For the rest of this paper we restrict ourselves to undirected 4-graphs, i.e. graphs whose vertices have at most four incident edges. A graph $G=(V,E)$ with $|V|=n$ and $|E|=m$ is called planar if it admits a drawing $\Gamma$ in the plane without edge crossings. Such a planar drawing of $G$ induces a (planar) embedding, which is represented by a circular ordered list of bordering edges for every face. The unbounded region of a planar drawing is called external face.

An orthogonal representation $H$ is an extension of a planar embedding that gives combinatorial information about the orthogonal shape of a drawing. For every edge we provide information about the bends encountered while traversing the edge and the angle formed at vertices by two consecutive edges. If one of these angles is 270° or 360° we associate with $v$ a reflex corner. An orthogonal representation is called normalized if it has no bends. An orthogonal grid drawing $\Gamma$ of $G$ is a drawing in which every edge is drawn as a sequence of horizontal and vertical edge segments and every vertex and bend has integer coordinates. Such a drawing induces an orthogonal representation $H_{\Gamma}$ and a star geometry for every vertex fixing the directions of the initial line segments of its incident edges. If an edge first turns to the right and then to the left, or vice versa, we call this a double bend and the edge segment between those two bends a middle segment. Every orthogonal representation can be normalized by replacing all bends in $H_{\Gamma}$ with dummy vertices of degree two, thus adding vertices to $G$ and $\Gamma$.

Since our new approach is based on a network flow model for one-dimensional compaction, we will give a brief introduction to minimum cost flows here. For more information about network flows, see [1]. Let $N=(V_{N},E_{N})$ be a directed graph. Whenever we talk about flows we will call $N$ a network, the members of $V_{N}$ nodes and the members of $E_{N}$ arcs (in contrast to vertices and edges in an undirected graph). Every arc $a$ has a lower bound $l(a)\in\bbbr^{\geq 0}$, an upper bound $u(a)\in\bbbr^{\geq 0}\cup\{\infty\}$ and a nonnegative cost $c(a)$. A demand $b(n)\in\bbbr$ is associated with every node. We call a function $x:A\rightarrow\bbbr^{\geq 0}$ a flow if $x$ satisfies the following conditions:

[TABLE]

A minimum cost flow is a flow $x$ with minimum total cost $c_{x}=\sum_{a\in E_{N}}x(a)c(a)$ under all feasible flows. The minimum cost flows we are interested in can be computed in $\mathcal{O}(|V_{N}|^{3/2}\log{}|V_{N}|)$ time [6].

3.2 Compaction of Orthogonal Drawings

We focus on the vertical (orthogonal) compaction problem that receives as input a planar grid drawing $\Gamma$ of a graph $G$ with an orthogonal representation $H_{\Gamma}$, and asks for another planar orthogonal drawing $\Gamma^{\prime}$ of $G$ realizing $H_{\Gamma}$ so that the vertical edge length is minimized subject to fixed $x$-coordinates. In the following we describe a flow-based method for vertical compaction similar to the coordinate assignment algorithm in Di Battista et al. [7].

Assume we have an initial grid drawing $\Gamma$. In a first step we normalize $H_{\Gamma}$ resulting in $\overline{\Gamma}$ and $\overline{H}_{\Gamma}$. Then we add vertical visibility edges (so-called dissecting edges). We insert a vertical edge connecting each reflex corner with the vertex or edge that is visible in vertical direction, possibly introducing dummy vertices. This gives us $\widetilde{\Gamma}$ and $\widetilde{H}_{\Gamma}$. This way we get rid of all reflex corners and have a representation with rectangular faces.

Now we are ready to construct the network $N_{y}$ for vertical compaction. For each face $f$ in representation $\widetilde{H}_{\Gamma}$ we add a node $n_{f}$ to $N_{y}$ with demand $b(n_{f})=0$ and for every vertical edge $e$ with left face $f_{l}$ and right face $f_{r}$ we insert an arc $a_{e}=(n_{f_{l}},n_{f_{r}})$ with lower bound $l(a_{e})=1$ and upper bound $u(a_{e})=\infty$. If $e$ is a dummy edge $a_{e}$ gets zero cost, otherwise a cost of one. See Fig. 2 for an example.

Suppose we have computed a feasible flow. Now a unit of flow corresponds to one unit of vertical edge length. The $x$-coordinates remain unchanged. The capacity constraint assures that every edge gets a minimum length of one and the flow conservation constraint guarantees that every face is drawn as a proper rectangle. Finally, the visibility edges and artificial vertices can be removed.

Lemma 1

The above algorithm solves the vertical compaction problem to optimality.

Proof

In the vertical compaction problem we have to preserve the vertical visibility properties of $\Gamma$ in order to avoid overlapping graph elements. This is achieved by the newly added visibility edges. Because of the one-to-one correspondence of vertical length of an edge segment in the resulting drawing $\Gamma^{\prime}$ and the amount of flow carried by a non-zero-cost arc $a_{e}\in N_{y}$, the result of the minimum cost flow gives us a minimal vertical length assignment.∎

4 The Fled-Five Compaction Approach

In this section we study the following relaxation of the one-dimensional compaction problem called the monotone flexible edge compaction problem with fixed vertex star geometry (Fled-Five compaction problem). For vertical compaction it is defined as follows: Given a planar grid drawing $\Gamma$ of a 4-graph $G$ with an orthogonal representation $H_{\Gamma}$, compute another planar grid drawing of $G$ that minimizes the vertical edge length subject to fixed $x$-coordinates in which all horizontal edge segments of $\Gamma$ are drawn $x$-monotonically the vertex star geometry for all vertices as well as the planar embedding is maintained.

In contrast to the classical compaction problem, it is not required here to realize the entire orthogonal representation, but only the local geometric surrounding of each vertex. The fixed $x$-coordinates and the $x$-monotonicity prohibits the lengthening of the total horizontal edge length (see Fig. 3).

We adapt the network flow approach described in Sect. 3.2. But now we are able to introduce or remove double bends of certain edges in order to improve the vertical edge length. We illustrate the concept by the following example. Figure 4(a) shows an optimally compacted drawing with respect to its orthogonal representation. The blue arcs show the arcs of the vertical compaction network (compare Fig. 2). For better readability we omitted the network nodes belonging to the faces. In Fig. 4(b), the same graph is shown, but with a different orthogonal representation. The new double bend in the middle edge leads to a smaller drawing. In this drawing it is possible to send flow between the two internal faces, since they are separated by a vertical edge segment. In the corresponding flow network there is a new network arc (red) connecting the upper and the lower face. This leads to the key idea of our approach. Introducing arcs in the vertical flow network between horizontally separated face nodes enables us to shift flow between them and therefore exchange vertical edge length at the expense of a double bend (see Fig. 4(c)). We can also reverse this thought. If there is an unnecessary double bend we can get rid of it by not sending flow over the arc corresponding to its middle segment and thus removing the middle segment from the drawing.

But we have to be careful here. First, we are compacting in vertical direction, so we cannot change the $x$-coordinates. If an edge has a double bend, it needs to have a horizontal expansion of at least two. Thus we will not consider edges of length one as possible candidates for getting a double bend. Second, adding a double bend to $e$ introduces two reflex corners, one in both adjacent faces of $e$. Two double bends may even cause an edge overlap, see Fig. 5(a). We need to ensure that the computed flow corresponds to a feasible drawing. Therefore we will treat each grid point along an edge that could be part of a double bend as a potential reflex corner, which we will eliminate by dissecting. We will now describe the algorithm in detail.

Our algorithm works in three phases: dissection, computation of a minimum cost flow and transforming the flow into a new drawing. First we normalize $H_{\Gamma}$ to $\overline{H}_{\Gamma}$. For dissection we split the horizontal edges of $\overline{\Gamma}$ by placing an artificial bend vertex on every inner grid point of an horizontal edge. The bend vertices may later be transformed to double bends. Then we dissect $\overline{\Gamma}$ as described in Sect. 3 and treat every bend vertex as a reflex corner in its adjacent faces (see 5(b)). That means, we may dissect the drawing in vertical stripes of unit length. Doing so, we solve both of the problems mentioned above. Since we consider only edges of length at least two, we guarantee that the edge will be long enough for a double bend and by inserting the visibility edges we keep the vertical separation of graph elements intact. This results in the extensions $\widetilde{\Gamma}$ and $\widetilde{H}_{\Gamma}$ and $\widetilde{G}$.

Observation 1

After this dissection method the number of vertices and edges in $\widetilde{G}$ is $\mathcal{O}(A^{2})$, where $A=h_{\Gamma}\cdot w_{\Gamma}$ and $h_{\Gamma}$ ($w_{\Gamma}$) is the height (width) of $\Gamma$.

Next we construct the network from Sect. 3.2. Additionally to the already introduced arcs (blue arcs in Fig. 5) we add two arcs $a^{\uparrow}_{v}$ and $a^{\downarrow}_{v}$ for every bend vertex (red curved arcs in Fig. 5). Notice that every such bend vertex $v$ has four adjacent faces, one at the lower and upper left and right. If it lies on the external face, two of the adjacent faces may coincide. Arc $a^{\uparrow}_{v}$ goes from the lower left face of $v$ to its upper right face and $a^{\downarrow}_{v}$ goes from the upper left to the lower right face. Flow on one of these arcs will lead to a double bend in the edge segment of $G$ that is split by $v$. The lower bound of these arcs is zero, the upper bound is set to infinity and the cost is one. For every edge $e\in\widetilde{G}$ that is a middle segment in $G$ we decrease the lower bound of its arc $a_{e}$ to zero, since this is a vertical edge segment, that we may delete (orange arc in Fig. 5).

After computing a minimum cost flow in this network, we interpret the result in the following way: For every vertical edge $e$ of $\widetilde{G}$ we translate the amount of flow on the arc $a_{e}$ of $N_{y}$ to the length of $e$. Let $a^{\uparrow}_{v}$ be an arc corresponding to a bend vertex $v$ carrying $k$ units of flow. Let $e$ be the split horizontal edge and $x_{v}$ the $x$-coordinate of $v$. Then $e$ will start at its left endpoint in horizontal direction, bend downwards at $x$-coordinate $x_{v}$, proceed for $k$ units in $y$-direction and then continue to the right to its other endpoint. If we deal with an arc of the form $a^{\downarrow}_{v}$ the corresponding edge will do an upward bend at $x_{v}$. Let $e^{\prime}\in\widetilde{G}$ be an edge that corresponds to a middle segment and let $a_{e^{\prime}}$ be the corresponding arc. If $a_{e^{\prime}}$ carries no flow we do not assign any vertical length to $e^{\prime}$, hence the double bend to which $e^{\prime}$ belongs collapses. Notice that flow on every non-zero-cost arc corresponds to vertical edge length. Finally, we remove all dummy edges and vertices. See Fig. 5 for an example.

Let us assume that the width and height of $\Gamma$ are bounded by the number of its vertices and bends. Otherwise there would be a grid line without any vertex or bend on it. We can delete such grid lines iteratively until we reach our bound.

Theorem 4.1

Let $\Gamma$ be a planar grid drawing of a 4-graph $G$ with an orthogonal representation $H_{\Gamma}$. Let $\bar{n}$ be the number of vertices and bends of $\Gamma$. Then the above described extended network-based compaction algorithm takes $\mathcal{O}(\bar{n}^{3}\log{}\bar{n})$ time and solves the vertical Fled-Five compaction problem to optimality.

Proof

Because of the visibility edges we will maintain visibility properties of $\Gamma$. Every vertical edge segment of $G$ that is not a middle segment gets a minimum length of one due to the lower bound of the corresponding arc in $N_{y}$. Every bend vertex can savely be turned to a double bend if its corresponding arc carries flow, since we add visibility edges to the top and bottom of it. By this modification we do not change the vertex star geometry of $\Gamma$, because bend vertices are not part of $G$. Every middle segment can be removed if there is no flow on the corresponding arc. Because its edge $e\in\Gamma$ has a horizontal expansion of at least two, $e$ will still have a proper length and due to the dissection phase visibility properties are maintained. This modification also does not affect the vertex star geometry of $\Gamma$, since a middle segment is not adjacent to a vertex of $G$. So every face will have a rectangular shape, no matter what modification we apply, and due to flow conservation every face and thus the entire graph is drawn consistently. Similar to Lemma 3.2 the length of vertical segments of $\Gamma^{\prime}$ is equal to the cost of the computed minimum cost flow. The horizontal edge segments maintain their $x$-monotonicity, because we only add vertical segments to the drawing. Hence the horizontal edge lengths and the $x$-coordinates of the vertices in $\Gamma$ stay the same. Because the minimum cost flow gives us a minimal vertical length assignment we have an optimal solution for the vertical Fled-Five compaction problem.

For the running time we first consider the dissection phase. By Observation 1 we end up with $\mathcal{O}(\bar{n}^{2})$ vertices. For inserting dummy edges based on visibility properties we can use a sweep-line algorithm that runs in $\mathcal{O}(\bar{n}^{2}\log{}\bar{n})$ time in our case. The construction of the flow network runs in linear time in the size of $\widetilde{G}$. The network is planar and has $\mathcal{O}(\bar{n}^{2})$ nodes. For planar flow networks with $n$ nodes and $\mathcal{O}(n)$ arcs there exists a $\mathcal{O}(n^{3/2}\log{}n)$ time algorithm for computing a minimum cost flow [6]. Therefore we have a total running time of $\mathcal{O}(\bar{n}^{3}\log{}\bar{n})$. ∎

The cubic part of the running time comes from the possibly quadratic number of bend vertices and dissecting edges. So if we restrict the number of bend vertices to be linear, we can decrease the running time to $\mathcal{O}(\bar{n}^{3/2}\log{}\bar{n})$.

Controlling the Number of New Bends.

Although the above compaction approach may reduce the total edge length, the number of bends in the resulting drawing may increase. A possible approach to control the number of new bends could be to bound the number of specific arcs used by a feasible flow. This is known as the binary case of the budget-constrained minimum cost flow problem for which Holzhauser et al. [10] showed strong NP-completeness. In fact, in this model we have no other control over the number of additional bends than restricting the number of bend vertices. Each such vertex can generate two new bends.

5 Experimental Evaluation

In our experimental evaluation we compare the new compaction approach FF with the flow-based method TRAD described in Sect. 3. Both lead to a planar drawing with optimal total edge length for the according one-dimensional compaction problem.

The algorithm was implemented in C++ using the OGDF library [5]. We have computed orthogonal drawings in the traditional way using the topology-shape-metrics approach, applying a constructive compaction method in order to get a feasible planar grid drawing with a normalized orthogonal representation $H$. We have taken these drawings as input for both approaches FF and TRAD that repeatedly apply horizontal and vertical compaction steps until no further improvement can be achieved. Recall that although both approaches are optimal for the one-dimensional compaction problems, repeated application of horizontal and vertical compaction steps does in general not lead to drawings with optimal total edge length for the two-dimensional compaction problems. Notice also that due to the alternating repetitions in FF the monotonicity of edge segments may no longer be maintained.

We state the following hypotheses regarding the results of our new approach FF compared to those of TRAD:

1. (H1)

The total edge length and therefore the area of the drawings will decrease. We will also examine the change of the maximum edge length. It is hard to predict the behaviour, because on the one hand adding a double bend lengthens an edge, but it could also lead to shorter edges in other places. 2. (H2)

The number of bends will rise significantly. 3. (H3)

Although there will be many more dissecting edges, the running time will not increase drastically.

We tested our algorithm on three test suites. The standard benchmark set called Rome graphs introduced in [8] consists of about 11,000 real-world and real-world like graphs with 10 to 100 vertices. The second set of graphs are quasi-trees which are known to be hard to compact. They have already been used in the compaction literature (e.g., [13],[12]). From this, we selected a subset of 155 graphs with 40 to 450 vertices. The last set consists of 240 randomly generated biconnected planar 4-graphs with 40 to 500 vertices. All used graphs were, if necessary, initially turned into planar $4$-graphs by planarizing them with methods of OGDF and replacing vertices with $k>4$ outgoing edges with faces of size $k$. This results in graph sizes of up to 314 vertices for the Rome test suite and up to 475 vertices for the quasi-trees before the orthogonalization step. The input instances are available on https://ls11-www.cs.tu-dortmund.de/mutzel/compaction. All tests were run on an Intel Xeon E5-2640v3 2.6GHz CPU with 128 GB RAM.

(H1) Figure 6 shows on the left the average decrease of the total and maximum edge length as well as of the area in percent. In all three graph classes the total edge length as well as the area has improved. We were able to decrease the total edge length by up to 36.1% and the area by up to 68.7%. In general, larger graphs allow a larger improvement. It turned out that for the majority of the instances we were also able to reduce the maximum edge length. Only for the quasi-trees the longest edges produced by FF are longer on average. But in general the results are mixed, reaching from a lengthening by 87.5% to a shortening by 58.1%. Figure 7 shows absolute values for the total edge length and the maximum edge length measured for the biconnected graphs. (The plots for the other graph classes can be found in the Appendix.)

(H2) The right side of Fig. 6 displays the average increase of the number of bends. If an instance had no bends after TRAD, we use the number of bends after FF as relative increase to take also these instances into account for computing the average increase of bends. As expected the drawings produced by FF have many more bends, especially for the Rome graphs. In one of the worst cases the number of bends went up from zero to 72. Figure 7 shows the absolute values for the number of bends measured for the biconnected graphs. Figure 8 gives the relation between the number of invested bends and the improvement in terms of area and total edge length for the biconneced graphs. The data for the other two graph classes look similar.

(H3) We measured the total running time and the number of performed compaction iterations. For better comparison we also display the running time per iteration, because FF tends to do more iterations. The reason for that is that in one compaction step of FF changes the drawing and therefore the flow network of the next step more significantly, leading to more new possibilities in compacting. The right side of Fig. 6 displays the average increase of the running time and the number of visibility edges. In all cases the number of additional dissecting edges has increased significantly. The running time per iteration has also increased, but not more than 50% on average. Only for 252 instances of the Rome graphs and one biconnected graph the running time per iteration has more than doubled.

The results support the hypotheses. Our new approach is able to improve the drawing area and the total edge length by introducing additional bends. Figure 9 shows two examples drawn with TRAD and FF, respectively.

Acknowledgements. This work was supported by the DFG under the project Compact Graph Drawing with Port Constraints (DFG MU 1129/10-1). We would like to thank Gunnar Klau for providing us with most of our test instances. We also gratefully acknowledge helpful discussions with Martin Gronemann, Sven Mallach, and Daniel Schmidt.

Appendix

Additional Experimental Results

Figures 10 and 11 show the absolute values for the quasi trees and the Rome graphs. The three plots in Fig. 12 complement the absolute values for the biconnected graphs of Fig. 7. Figures 13 and 14 display the relation between additional bends and improvement of area and total edge length for the quasi trees and for the Rome graphs.