Hierarchical Aggregation for Information Visualization: Overview, Techniques, and Design Guidelines <s> Aggregated Treemaps <s> The traditional approach to representing tree structures is as a rooted, directed graph with the root node at the top of the page and children nodes below the parent node with lines connecting them (Figure 1). Knuth (1968, p. 305-313) has a long discussion about this standard representation, especially why the root is at the top and he offers several alternatives including brief mention of a space-filling approach. However, the remainder of his presentation and most other discussions of trees focus on various node and edge representations. By contrast, this paper deals with a two-dimensional (2-d) space-filling approach in which each node is a rectangle whose area is proportional to some attribute such as node size. <s> BIB001 </s> Hierarchical Aggregation for Information Visualization: Overview, Techniques, and Design Guidelines <s> Aggregated Treemaps <s> Existing information visualization techniques are usually limited to the display of a few thousand items. This article describes new interactive techniques capable of handling a million items (effectively visible and manageable on screen). We evaluate the use of hardware-based techniques available with newer graphics cards, as well as new animation techniques and non-standard graphical features such as stereovision and overlap count. These techniques have been applied to two popular information visualizations: treemaps and scatter plot diagrams; but are generic enough to be applied to other 2D representations as well. <s> BIB002 </s> Hierarchical Aggregation for Information Visualization: Overview, Techniques, and Design Guidelines <s> Aggregated Treemaps <s> We present Growing Polygons, a novel visualization technique for the graphical representation of causal relations and information flow in a system of interacting processes. Using this method, individual processes are displayed as partitioned polygons with color-coded segments showing dependencies to other processes. The entire visualization is also animated to communicate the dynamic execution of the system to the user. The results from a comparative user study of the method show that the Growing Polygons technique is significantly more efficient than the traditional Hasse diagram visualization for analysis tasks related to deducing information flow in a system for both small and large executions. Furthermore, our findings indicate that the correctness when solving causality tasks is significantly improved using our method. In addition, the subjective ratings of the users rank the method as superior in all regards, including usability, efficiency, and enjoyability. <s> BIB003 </s> Hierarchical Aggregation for Information Visualization: Overview, Techniques, and Design Guidelines <s> Aggregated Treemaps <s> Here, we analyze toolkit designs for building graphical applications with rich user interfaces, comparing polylithic and monolithic toolkit-based solutions. Polylithic toolkits encourage extension by composition and follow a design philosophy similar to 3D scene graphs supported by toolkits including JavaSD and Openlnventor. Monolithic toolkits, on the other hand, encourage extension by inheritance, and are more akin to 2D graphical user interface toolkits such as Swing or MFC. We describe Jazz (a polylithic toolkit) and Piccolo (a monolithic toolkit), each of which we built to support interactive 2D structured graphics applications in general, and zoomable user interface applications in particular. We examine the trade offs of each approach in terms of performance, memory requirements, and programmability. We conclude that a polylithic approach is most suitable for toolkit builders, visual design software where code is automatically generated, and application builders where there is much customization of the toolkit. Correspondingly, we find that monolithic approaches appear to be best for application builders where there is not much customization of the toolkit. <s> BIB004 </s> Hierarchical Aggregation for Information Visualization: Overview, Techniques, and Design Guidelines <s> Aggregated Treemaps <s> Treemaps provide an interesting solution for representing hierarchical data. However, most studies have mainly focused on layout algorithms and paid limited attention to the interaction with treemaps. This makes it difficult to explore large data sets and to get access to details, especially to those related to the leaves of the trees. We propose the notion of zoomable treemaps (ZTMs), an hybridization between treemaps and zoomable user interfaces that facilitates the navigation in large hierarchical data sets. By providing a consistent set of interaction techniques, ZTMs make it possible for users to browse through very large data sets (e.g., 700,000 nodes dispatched amongst 13 levels). These techniques use the structure of the displayed data to guide the interaction and provide a way to improve interactive navigation in treemaps. <s> BIB005 </s> Hierarchical Aggregation for Information Visualization: Overview, Techniques, and Design Guidelines <s> Aggregated Treemaps <s> We present the zoomable adjacency matrix explorer (ZAME), a visualization tool for exploring graphs at a scale of millions of nodes and edges. ZAME is based on an adjacency matrix graph representation aggregated at multiple scales. It allows analysts to explore a graph at many levels, zooming and panning with interactive performance from an overview to the most detailed views. Several components work together in the ZAME tool to make this possible. Efficient matrix ordering algorithms group related elements. Individual data cases are aggregated into higher-order meta-representations. Aggregates are arranged into a pyramid hierarchy that allows for on-demand paging to GPU shader programs to support smooth multiscale browsing. Using ZAME, we are able to explore the entire French Wikipedia - over 500,000 articles and 6,000,000 links - with interactive performance on standard consumer-level computer hardware. <s> BIB006
In this example, we study how to augment an existing zoomable treemap visualization BIB001 , BIB005 with hierarchical aggregation support. In this way, we can turn the visualization into a multiscale structure suitable for supporting both overview as well as detail tasks. We start our design from a basic slice-and-dice treemap BIB001 implemented in Piccolo BIB004 (Fig. 17) . The visualization already supports zoom and pan (Section 3.5.1) in geometric space, as well as flipping (Section 3.5.4) for visiting sibling nodes. However, the hierarchies that we want to represent using this visualization, such as a filesystem directory structure, may become arbitrarily large (easily more than 1 million entities BIB002 ). This immediately gives rise to the two basic problems of large-scale data sets, performance and perception. . Performance: Rendering performance will suffer for very large hierarchies. . Perception: It is difficult, if not impossible, to get an overview of the data set due to the large number of visual entities. To help remedy this situation, we can apply design guideline G1 (entity budget) to begin introducing hierarchical aggregation to the visualization. In this case, we can utilize the tree structure itself as the aggregation hierarchy, saving us some work. Furthermore, G1 tells us that we can address both of the above problems by maintaining a visual entity budget and not propagate deeper into the aggregation hierarchy than necessary. In particular, there is clearly no need to draw any nodes that are smaller than a pixel for a given level of zoom. For this situation, we replace the visual representation of the aggregate and its children with a checkered pattern to communicate to the viewers that there is additional underlying data to be seen if they zoom in (G2). While this pattern may conflict with G3 (visual simplicity), it is better than the alternative, i.e., to attempt to draw all of the nodes, even though they are smaller than a pixel each. Furthermore, we believe that the checkered pattern still gives a clear visual indication that there is more to see in the checkered area. However, while our entity budget solves our performance problems by capping the amount of entities to draw at any time, it has not fully solved the perception problem because this budget may still be larger than the information processing capacity of the viewer. To better support overview, we introduce local aggregation control (Section 3.5.3), where the user can selectively expand and collapse branches by rolling the mouse wheel or clicking (left-click for expand and right-click for collapse) individual entities on the display. This gives the user direct control of which detail level to view the hierarchy, while simultaneously supporting drill-down and roll-up operations (Section 3.5.2). According to guideline G4, we must now make sure that aggregates and items can be easily distinguished. We achieve this by coloring aggregates blue, while items remain green. This also gives a straightforward indication that there is more information to be gleaned if the user simply expands a specific aggregate. Other possibilities to communicate this may have been to use a special border for the aggregate nodes, or to add a drop shadow or a "stack" graphic to the node (like for the processes in the growing polygons BIB003 technique). We can now make the observation that by cutting down on the visual complexity as described above, we have also reduced the amount of information conveyed through the visualization. Guideline G2 tells us that aggregates should communicate information about the underlying (aggregated) data, while guideline G5 admonishes us to be conservative in doing so, lest we end up with an even more visually complex display than before. Our solution is to introduce a family of simple glyphs (similar to the glyphs in the ZAME BIB006 system) drawn in the corner of each treemap node that shows various metrics of the contained subtree. In particular, we use a small bar histogram to show the distribution of file sizes in a directory structure (Fig. 18) . When designing the glyphs, we must also be mindful of guideline G5, which tells us to indicate the decreased fidelity of the glyph representations; interactive aggregation control also helps in this. However, at this point, we note that the rectilinear appearance of a histogram rendered as a bar chart may be easily confused with the rectilinear visual representation of the treemap. This conflicts with guideline G4, which states that visual aggregates should be easily distinguishable, as well as to some extent G3, which argues for a clean visual appearance of visual aggregates. To avoid this conflict, we must find a visual appearance for the histogram glyph that is easily distinguishable from the treemap representation. One option may be to round the edges of the bar chart glyph, but this may not be sufficient for accurate disambiguation. Instead, we choose to add a new type of glyph based on pie charts to make the distinction perfectly clear. Another important point to consider is guideline G6, which states that taking the aggregation too far may cause misinterpretation. Fortunately, treemaps generally have high interpretability due to their parent-child layout. However, for our aggregated treemap, initializing the visualization to show only the root of the tree as a single visual aggregate may cause the viewer to misunderstand the data, or even think that there is nothing more to see in the visualization. A simple solution is to expand the first few levels of the tree upon initialization, as well as to explicitly show that there is underlying data to explore, for example, by giving the number of children in a tooltip or label. Fig. 19 shows the final redesigned version of our treemap visualization, now with support for hierarchical aggregation. The visualization has been implemented in Java using the Piccolo BIB004 toolkit, and can be executed using a Web browser from the following URL: https://engineering. purdue.edu/elm/projects/aggtreemap/.