Visualizing Large Hierarchies with Drawer Trees
Yalong Yang1 , Ning Dou1 , Shuai Zhao1 , Zhichao Yang1 , Kang Zhang1,2 , Quang Vinh Nguyen3
1
School of Computer Software, Tianjin University, Tianjin, China
2
Department of Computer Science, The University of Texas at Dallas, Richardson, TX 75083, USA
3
MARCS Institute & School of Computing, Eng. and Maths, University of Western Sydney, Sydney, Australia
{yalongyang, dawning, zshuai, yangzc, kzhang}@tju.edu.cn, q.nguyen@uws.edu.au
ABSTRACT
Enclosure partitioning approaches, such as Treemaps, have
proved their effectiveness in visualizing large hierarchical
structures within a compact and limited display area. Most
of the Treemaps techniques do not use node-links to show the
structural relations. This paper presents a new tree visual-
ization approach known as Drawer-Tree that can be used to
present the structure, organization and interrelation of big
data. By utilizing the display space with traditional node-
link visualization, we have developed a novel method for
visualizing tree structures with high scalability. The name
“drawer” is a metaphor that helps people understand the
visualization.
Categories and Subject Descriptors
H.5.4 [Information Interfaces and Presentation]: Hy-
pertext/Hypermedia—Navigation,User Issues
General Terms
Human factors
Keywords
Information visualization, graph drawing, tree visualization,
treemaps, hierarchy
1. INTRODUCTION
Much of data we use today has hierarchical structures.
The natural form of this structure includes file systems, busi-
ness organizations, university/department structure, family
tree, manuals catalogs, and library catalogs and other. Such
structures not only play significant roles in their own right,
but also provide means for representing the structure of a
complex domain in a manageable form. Small hierarchi-
cal structures (such as traditional node-link diagrams or file
browsers) are an effective mean for users to location informa-
tion, but information embedded in larger hierarchies can be
Permission to make digital or hard copies of all or part of this work for
personal or classroom use is granted without fee provided that copies are
not made or distributed for profit or commercial advantage and that copies
bear this notice and the full citation on the first page. To copy otherwise, to
republish, to post on servers or to redistribute to lists, requires prior specific
permission and/or a fee.
SAC’14 March 24-28, 2014, Gyeongju, Korea.
Copyright 2014 ACM 978-1-4503-2469-4/14/03 ...$15.00.
http://dx.doi.org/10.1145/2554850.2554870
harder to grasp unless the nodes/branches are systematically
laid out in the rendering environment [5]. Unfortunately in
real world, these hierarchical structures are often very large
with thousands or even millions of elements and relation-
ships. As a result, providing an interactive visualization of
the entire structure, with capability for deep exploration at
different levels of granularity and compromise multiple aes-
thetic criteria graph drawing [6] are crucial for the analysts
in the knowledge discovery process.
Space-filling visualization, such as Treemaps techniques
[5, 9, 4], is novel approach for visualizing large tree struc-
tures in a 2D using enclosure partition for space utilization.
Treemaps have been considered to be a successful method for
visualizing large hierarchical data sets with attributed prop-
erties. The treemap algorithm works by dividing the display
area into a nested sequence of rectangles whose areas corre-
spond to an attribute of the dataset, effectively combining
aspects of a Venn diagram and a pie chart [4]. These set
of rectangles are referred to as the layout of the Treemaps.
Voronoi’s treemap [2] shows a new way to visualize things
in arbitrary polygons rather than rectangles, but only with
simple relationships between items. Interactive control al-
lows users to specify the presentation of both structural and
content information [22]. This is in contrast to traditional
static methods of displaying hierarchically structured infor-
mation, which generally makes either poor use of display
space or hide vast quantities of information from users. Al-
though Treemaps were originally designed to visualize files
on a hard drive [21], they have been applied to a wide variety
of areas ranging from financial analysis [23], sport reporting
[8], image browsing [3] and software and file system analysis
[1].
Although space-filling is a great approach for visualizing
large hierarchies, most of these techniques do not show the
relational structure of information explicitly. This costs ex-
tra cognitive effort for viewers to perceive and understand
the relational structures that are presented implicitly in the
enclosure manner [14], the fast rectangle-packing algorith-
m [7] shows a clear relationships, but the cost of calcula-
tion is high. This paper presents a new tree-based informa-
tion visualization technique for visualizing large hierarchical
structures, called drawer tree. We aim to utilize the dis-
play space in layout algorithm by combining enclosure and
modified fractal approach whilst maintaining a clear hier-
archical presentation with traditional node link style. In
addition to presenting readily observable information per-
taining to records in a collection, the use of clustering of the
tree branches and different color schema and branch thick-
951
ness for different depth level of the tree also convey density
and collection organizational/structural information to the
user.
2. RELATED WORK
Traditional methods for the presentation of hierarchically
structured information can be roughly classified into three
categories: listings, outlines, and tree diagrams. It is diffi-
cult for people to extract information from large hierarchical
information structures using these methods, as the naviga-
tion of the structure is a great burden and content infor-
mation is often hidden within individual nodes [24]. There
are two approaches for visualizing tree structures, includ-
ing the connection approach (such as Classical Hierarchical
View [19], H-tree Layout [20], Hyperbolic Browser [12], B-
otanical Visualization [10]) and the enclosure approach (such
as Treemaps [5, 9, 4, 13]) and combined approach (such as
SO-Tree [14] and Enccon [15]. They are both effective ap-
proaches for the visualization of hierarchies and the use of
each approach depends primarily on the properties of the
data in a particular application domain.
A complete review of all of the methods is outside the
scope of this paper. We only discuss visualization techniques
that are related to our drawer-tree visualization.
In a hyperbolic tree [12], there is a starting node at the
center of a hyperbolic tree. All the related entities are di-
rectly linked to it by arcs. The hyperbolic tree provides
varying level of details depending on the center position by
displaying the node which the user is interested in on the
center and in full detail, while other nodes on the side with
reduced detail. Although the hyperbolic browser is an in-
teresting technique for navigating/browsing complex sets of
data, it does not scale well when a parent node has many
children, since it becomes impossible to identify individual
nodes.
Botanical tree [10] visualization uses the strand model of
Holton to convert an abstract tree into a geometric mod-
el where non-leaf nodes are mapped to branches and child
nodes to sub-branches. The botanical tree method exhibit-
s characteristics of self-similarity [18] and the arrangement
of the branches makes it very similar to a 3D construction
of the fractal patterns discussed in [11]. According to the
results reported by the authors, users are intrigued and s-
timulated by the visualization. However, there are several
inherent problems with this technique:
1) Potential occlusion of branches and spheres and
2) Inspection of information (files) mapped onto a spheres
is inconvenient for users as they are mapped onto a spherical
shape.
Beam trees [25] offer a new twist to the treemap approach
by scaling down individual nodes in a treemap to introduce
occlusion as an extra depth cue while retaining the size pro-
portionality of Treemaps. Since rendition of beam trees is
accomplished via layered views of structure, visualization
of records in this multilayer structure can be confusing for
users because occlusion and overlapping of the rectangles
requires users to pan, flip or rotate the view camera. In ad-
dition, navigation in the beam tree can be tricky for users
and could also result in loss of contextual cue because users
have to either zoom-in or eliminate layers that are overlaid
upon the structures in the middle of the beam tree in order
to inspect the information.
Fractal tree-based information visualization techniques [16,
952
17] exhibit the space filling characteristics of treemap and
beam tree. They are, however, difficult for users to compare
sizes between different rectangles, high aspect ratios in large
collections. The problems in reconstructing the hierarchical
information do not exist due to its close resemblance to the
traditional node-link visualization.
Many fractal patterns can be adopted to convert a tra-
ditional node-link tree to a 2D fractal tree [16]. More im-
proved techniques have been presented to enhance the effi-
ciency and qualities of the fractal trees. These techniques
have been proven to be effective for small trees, but gener-
ally ineffective when more than thousands elements have to
be visualized simultaneously.
In addition, record density and hierarchies represented by
these techniques are difficult to perceive due to the layout
algorithms and the absence of visual cues on the tree branch-
es. In comparison, our drawer tree generate a visualization
of data in a collection without overlapping of branches and
information pertaining to a record is mapped onto color cod-
ed branches so that users may acquire density and clustering
information immediately.
3. DRAWER TREE
We call our approach drawer tree that resembles drawers
in a large cabinet and clearly distinguishes parent nodes from
leaf nodes. Parent nodes could be considered “drawers”, i.e.
containers that include leaf nodes.
The drawer tree is a 2D tree expanding in two orthogo-
nal directions. It aims at addressing the following design
criteria:
• Improve space efficiency
• Provide clear hierarchy presentation
• Enhance the visibility of leaf nodes and parent nodes
• Show useful information with attributed properties,
such as space and colors
• Provide interactions for exploring through the struc-
ture
• Support scalability when handling big data sets
Following sections describe the technical details of the
Drawer Tree.
3.1 Nodes
To distinguish leaf nodes and parent (or non-leaf) nodes,
we represent them differently.
3.1.1 Non-leaf Nodes
In a hierarchical structure, a parent node has other nodes
as its children. In a drawer tree, a parent node is used to
represent the drawer.
The parent node has the following properties when pre-
senting the hierarchical information (see Figure 1):
• Orientation: horizon or vertical;
• Length: the measure along the orientation;
• Gap: the space between two nodes;
• Thickness: the thickness of the node’s rectangle;
• Space: the rectangle formed by gap, length and thick-
ness;
• Edge: the line at the node’s rectangle’s top and bot-
tom, make it more like a drawer;
• Color: representing a property of the object, for ex-
ample, the file type in a file system;

Figure 1: Properties of a non-leaf node
• Name: name of the object;
• Description: a detail description of the object;
• Child nodes: with a parent node in the hierarchy rela-
tionship;
3.1.2 Leaf Nodes
A leaf node has no children, and is used to represent the
document in the drawer, such as a file in file system. D-
ifferent from a parent node, the drawer tree uses a line to
represent the leaf node. The leaf node has properties: orien-
tation, length, gap, space, color, name, description, as shown
in Figure 2.
Figure 2: Properties of a leaf node
3.2 Space parameters and calculation
The space parameters include location, i.e. a (x, y) co-
ordinate pair in the drawing space, apart from length and
gap as defined previously. A node’s space parameters would
affect the space parameters of its child nodes.
To compute a node’s position, we first sort the node’s child
nodes based on a particular attribute, such as the creation
time of a file in the file system application.
To make it easier to distinguish parent nodes and leaf
nodes, a parent node will hold all its child nodes, it will
first put the nodes that have child nodes in front, and then
put the other nodes. All the child nodes will use up all the
space of their parent node. Therefore, the parent node will
determine how many spaces the child should have.
3.2.1 For a parent node
Depending on the application, the drawer tree uses an
attribute of the data (may be considered weight) as the space
factor. For example, in a file system application, we could
use the disk size of a folder to determine the space for that
953
folder, the bigger size, the more space it is allocated.
In most cases, this way of space allocation works well.
In some situations, however, the particular attribute of each
node that is used as the weight may vary much. For example,
a file A has the disk size 1KB, another file B has the disk
size 1024KB, if we use the above space allocation method,
node B in the drawer tree will take 1024 times of A’s space.
This is apparently undesirable in the visualization, since A
is comparably too small to be noticeable. The drawer tree
uses a gradient decreasing function to solve the problem.
0
w = log2 (w + 2) (1)
0
where w represents the original weight, and w represents
the weight the drawer tree using to calculate the space. Us-
ing Formula 1, in a file system, a 1024KB node takes 6.31
times in space of the 1KB node.
After calculating all the weights, each parent node will use
the gap of its parent as its length, and use the weight to set
the gap. The gap is calculated by Formula 2.
0
w
gn = l ∗ Pn n 0 (2)
i=1 wi
where gn represents the gap the nth node’s gap taking
0
from its parent, l is the length of its parent node, wn is the
weight of the nth node, the denominator shows the sum of
all the child nodes.
3.2.2 For a leaf node
In many cases, there are many more leaf nodes than parent
nodes. Experiments have shown that if we follow the same
partitioning process for the parent node, the visualization
tends to be very crowded with leaf nodes. Therefore, the
drawer tree calculates the space of leaf nodes in either of the
following ways.
• If the space is enough for all the leaves, the drawer
tree will use the same method as the parent nodes, as
shown in Figure 2.
• Let us consider the following example: a node’s gap
has 100 pixels, but it has 500 leaf nodes as its chil-
dren, obviously the space is not enough even when all
leaf nodes have the same weight. If they have different
weights, the situation will be worse. To solve this prob-
lem, the drawer tree gives parent nodes higher priority
for space, since the length of a leaf is not as important
as it is for a parent node, which needs space to ac-
commodate its children. The space may be utilized by
making more levels for leaves, though a balance needs
to be found since too many levels would make visu-
alization ineffective. To find an effective balance, the
drawer tree uses Formula 3 to compute the number of
the levels.

 Pn wi
0 

 i=0 0
wmin 

lc = tg ∗ +1 (3)

ll
where lc is the number of the levels, tg measures the
minimum gap between two leaves, ll is the length left
0
for all the leaves, wmin is the leaf node having the
minimum weight. In this way the gap for each leaf can
 be shown in Formula 4. The drawer tree supports two types of interactions: navi-
0 gation and drill down to details, as described below.
w
gn = lc ∗ ll ∗ Pn n 0 (4)
i=1 wi 3.4.1 Navigation
Since there are levels in leaves, the length of the leaves The drawer tree currently supports three navigation modes:
cannot just take the gap of their parent. It can be zoom in, zoom out and back to top.
shown in Formula 5. a) Zooming in
g The drawer tree handles the left click event of the mouse,
ln = − tl (5) and finds the node being clicked, then make this node the
lc
root and redraws the entire tree, as demonstrated in Figure
where g represents the gap of the leaves’ parent node,
4.
tl is a parameter that shows the gap between different
levels. An example is presented in Figure 3.

Figure 4: Zoom-in effect

b) Zooming out
The drawer tree handles the right click event of the mouse,
and makes the last root as the current root node and redraws
the tree, as presented in Figure 5.
Figure 3: Narrowed leaves at multiple levels
3.3 Coloring strategy
The drawer tree is colored, and uses two coloring strategies
as explained below.
3.3.1 Coloring for type
In many applications, data can be classified into types.
The drawer tree uses different colors to represent types, al- Figure 5: Zoom-out effect
lowing users to find data of a given type easily. For example,
c) Back to top
in file system, files can be classified by their types: video,
The drawer tree handles the right double-click event of
audio, picture, text and so on.
the mouse, or the swipe gesture on a touch screen device. It
3.3.2 Coloring for weight and relationships makes the first root node as the root and redraws the entire
tree, as presented in Figure 6.
The other strategy is using the color to represent the
weight information of the nodes. The drawer tree will use
the HSI color scheme to annotate the nodes.
The progress can be described as:
a) Hue range for relationships between a node and its
children
The calculation method is like in Formula 2, the children
will share the hue range of their parent, and in this way we
can easily see the parent-child relationship from color. Figure 6: Back to top
b) Saturation for node level
The saturation can be shown in Formula 6. 3.4.2 Drill down to detailed information
The drawer tree will detect the location of the mouse in
sn = n/nmax (6)
real time, and find the node that contains the mouse lo-
where sn is the saturation of the nodes at the nth level, cation, then draw a box to illustrate this node’s detailed
nmax is the maximum level for the drawer tree. information. The result is shown in Figure 1 and Figure 2.
c) Color intensity for node weight
We make the color intensity correspond to a node’s weight. 4. A CASE STUDY
The heavy the weight is, the darker the intensity.
In this case study, we use the drawer tree to visualize
3.4 Interactions file system to illustrate its visualization effectiveness and
scalability.
Interactions are extremely important for navigating the
In this experiment, the drawer tree has the following char-
visualization space, especially when the drawer tree has a
acteristics:
large number of nodes. The user may wish to focus on some
specific parts of big data. Meanwhile, the drawer tree could • Taking the file size as the weight property
show the most important properties of the data, rather than • Taking the modified time as the sorting property
all the properties. • Coloring file types systematically
954
 Figure 7: Drawer tree using C disk folder on Windows, including 305,800 files and folders
Since the drawer tree uses a color scheme for file types,
we need a color table to map different file types, as shown
in Figure 8.
Figure 8: Color coding for different file types
First, the drawer tree uses the eclipse software’s folder as
its data, the result is shown in Figure 9. We can easily see
the folder in the middle of the tree has many application files
(pink color), also, the folder “bundle” has many sub-folders,
and so on.
Figure 9: Drawer tree using eclipse folder, 4191 n-
odes
955
The drawer tree can also visualize big data. Figure 7
presents the visualization of the data in the folder “C:\” on
Windows.
In Figure 7, there are two large files, hiberfill.sys (6.3G-
B) and pagefile.sys (2.1GB), the properties of both file are
shown clearly, the two files use a lot of space because of their
large size. Also these two files frequently change their data,
so their locations are always in front of all the leaves.
Figure 10: Drawer tree with a c# project
Another use case is shown in the Figure 10 which visu-
alizes a C# project. The figure clearly shows that all the
project files can be divided into two parts, one with many
source code files, the other which include application files
together with DLL files. More importantly, the drawer tree
sorts the files based on their modified time, from which, one
can easily find useful informations:
• The file TempleteDataManager.cs was modified recent-
ly.
• The file AlgorithAllInOne.csproj was modified recent-
ly, and since it describes the project that shows files
being added or deleted from the project.
5. CONCLUSION & FUTURE WORK
This paper has presented a novel 2D hierarchical visual-
ization, called Drawer Tree. Experiments showed that the
drawer tree algorithm had the capability for visualization of
large data sets. We also provided various interactions and
attributed properties to improve readability and aspect ra-
tio. Our method utilized the fractal tree-based approach
whose branches expanded in 4 directions. The branches of
drawer tree are more orderly and thus the space utilization
is higher. In addition, the actual tree structures presented in
traditional node-link visualizations are properly preserved in
this visualization as branches at different positions are color
coded and arranged in the appropriate orientation.
We are planning to add more visual properties, and also
let users customize to meet their needs in particularly appli-
cations. We will apply our techniques to other applications
and data sets. Finally, we will conduct a formal usability
study to evaluate the effectiveness of our approach.
6. REFERENCES
[1] M. J. Baker and S. G. Eick. Space-filling software
visualization. Journal of Visual Languages and
Computing, 6(2):119–133, 1995.
[2] M. Balzer, O. Deussen, and C. Lewerentz. Voronoi
treemaps for the visualization of software metrics. In
Proceedings of the 2005 ACM symposium on Software
visualization, pages 165–172. ACM, 2005.
[3] B. B. Bederson. Quantum treemaps and bubblemaps
for a zoomable image browser. Proc. User Interface
Systems and Technology, pages 71–80, 2001.
[4] B. B. Bederson, B. Shneiderman, and M. Wattenberg.
Ordered and quantum treemaps: Making effective use
of 2d space to display hierarchies. ACM Transactions
on Graphics (TOG), 21(4):833–854, 2002.
[5] M. Bruls, K. Huizing, and J. J. Van Wijk. Squarified
treemaps. In Data Visualization 2000, pages 33–42.
Springer, 2000.
[6] W. Huang, P. Eades, S.-H. Hong, and C.-C. Lin.
Improving multiple aesthetics produces better graph
drawings. Journal of Visual Languages & Computing,
2012.
[7] T. Itoh, Y. Yamaguchi, Y. Ikehata, and Y. Kajinaga.
Hierarchical data visualization using a fast
rectangle-packing algorithm. IEEE Transactions on
Visualization and Computer Graphics, 10(3):302–313,
2004.
[8] L. Jin and D. Banks. Tennisviewer: A browser for
competition trees. Computer Graphics and
Applications, IEEE, 17(4):63–65, 1997.
[9] B. Johnson and B. Shneiderman. Tree-maps: A
space-filling approach to the visualization of
hierarchical information structures. In Proceedings of
1991 IEEE Visualization, pages 284–291. IEEE, 1991.
[10] E. Kleiberg, H. Van De Wetering, and J. J. Van Wijk.
Botanical visualization of huge hierarchies. In InfoVis,
volume 1, page 87, 2001.
[11] H. Koike. Fractal views: a fractal-based method for
controlling information display. ACM Transactions on
Information Systems (TOIS), 13(3):305–323, 1995.
[12] J. Lamping and R. Rao. The hyperbolic browser: A
focus+ context technique for visualizing large
956
hierarchies. Journal of Visual Languages &
Computing, 7(1):33–55, 1996.
[13] J. Liang, S. Simoff, Q. V. Nguyen, and M. L. Huang.
Visualizing large trees with divide & conquer
partition. In Proceedings of the 6th International
Symposium on Visual Information Communication
and Interaction, pages 79–87. ACM, 2013.
[14] Q. V. Nguyen and M. L. Huang. Space-optimized tree:
a connection+ enclosure approach for the visualization
of large hierarchies. Information Visualization,
2(1):3–15, 2003.
[15] Q. V. Nguyen and M. L. Huang. Enccon: an approach
to constructing interactive visualization of large
hierarchical data. Information Visualization,
4(1):1–21, 2005.
[16] Q. V. Nguyen, S. Simoff, and M. L. Huang. Interactive
visualization with user perspective: a new concept. In
Proceedings of the 3rd International Symposium on
Visual Information Communication, page 16. ACM,
2010.
[17] T. Ong, J. J. Leggett, and U. Yun. Visualizing
hierarchies and collection structures with fractal trees.
In Proceedings of Sixth Mexican International
Conference on Computer Science, pages 31–40. IEEE,
2005.
[18] H.-O. Peitgen, H. Jürgens, and D. Saupe. Chaos and
fractals: new frontiers of science. Springer, 2004.
[19] E. M. Reingold and J. S. Tilford. Tidier drawings of
trees. IEEE Transactions on Software Engineering,
(2):223–228, 1981.
[20] Y. Shiloach. Arrangements of planar graphs on the
planar lattice. PhD thesis, PhD thesis, Weizmann
Institute of Science, 1976.
[21] B. Shneiderman. Tree visualization with tree-maps:
2-d space-filling approach. ACM Transactions on
Graphics (TOG), 11(1):92–99, 1992.
[22] B. Shneiderman. The eyes have it: A task by data
type taxonomy for information visualizations. In
Proceedings of 1996 IEEE Symposium on Visual
Languages, pages 336–343. IEEE, 1996.
[23] Smartmoney. Map of the market.
http://www.smartmoney.com/map-of-the-market/,
2013.
[24] J. Stasko, R. Catrambone, M. Guzdial, and
K. McDonald. An evaluation of space-filling
information visualizations for depicting hierarchical
structures. International Journal of Human-Computer
Studies, 53(5):663–694, 2000.
[25] F. Van Ham and J. J. van Wijk. Beamtrees: Compact
visualization of large hierarchies. Information
Visualization, 2(1):31–39, 2003.