Renaud Blanch

Browsing Zoomable Treemaps: Structure-Aware Multi-Scale Navigation Techniques

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.

Programming rich interactions using the hierarchical state machine toolkit

Structured graphics models such as Scalable Vector Graphics (SVG) enable designers to create visually rich graphics for user interfaces. Unfortunately current programming tools make it difficult to implement advanced interaction techniques for these interfaces. This paper presents the Hierarchical State Machine Toolkit (HsmTk), a toolkit targeting the development of rich interactions. The key aspect of the toolkit is to consider interactions as first-class objects and to specify them with hierarchical state machines. This approach makes the resulting behaviors self-contained, easy to reuse and easy to modify. Interactions can be attached to graphical elements without knowing their detailed structure, supporting the parallel refinement of the graphics and the interaction.

Two touch system latency estimators: high accuracy and low overhead

The end-to-end latency of interactive systems is well known to degrade users performance. Touch systems exhibit notable amount of latencies, but it is seldom characterized, probably because latency estimation is a difficult and time consuming undertaking. In this paper, we introduce two novel approaches to estimate the latency of touch systems. Both approaches require an operator to slide a finger on the touch surface, and provide automatic processing of the recorded data. The High Accuracy (HA) approach requires an external camera and careful calibration, but provides a large sample set of accurate latency estimations. The Low Overhead (LO) approach, while not offering as much accuracy as the HA approach, does not require any additional equipment and is implemented in a few lines of code. In a set of experiments, we show that the HA approach can generate a highly detailed picture of the latency distribution of the system, and that the LO approach provides average latency estimates no further than 4 ms from the HA estimate.

Improving Visualization of Large Hierarchical Clustering

The classical representation of a binary tree generated by a hierarchical clustering is a node-link-based visualization denoted as a dendrogram. It allows users to explore in a simple way the clusters and the relationships between instances. However, exploration of large dendrograms is known to be difficult due to the graphical and cognitive information overload involved. Here, we discuss the current approaches and we introduce Stacked Trees, a new Focus+Context visualization technique that allows the exploration of the hierarchical clustering of up to fifty thousands nodes on a standard-sized screen.

Programmer I'interaction avec des machines à états hiérarchiques

Writing interactive software leads, due to the lack of adapted control structures, to a code that is difficult to maintain and reuse. Formalisms adapted to the description and to the specification of interactions do exist. This paper proposes to extend imperative programming languages with a control structure borrowed from one of those formalisms: the hierarchical state machines.

Dendrogramix: A hybrid tree-matrix visualization technique to support interactive exploration of dendrograms

Clustering is often a first step when trying to make sense of a large data set. A wide family of cluster analysis algorithms, namely hierarchical clustering algorithms, does not provide a partition of the data set but a hierarchy of clusters organized in a binary tree, known as a dendrogram. The dendrogram has a classical node-link representation used by experts for various tasks like: to decide which subtrees are actual clusters (e.g., by cutting the dendrogram at a given depth); to give those clusters a name by inspecting their content; etc. We present Dendrogramix, a hybrid tree-matrix interactive visualization of dendrograms that superimposes the relationship between individual objects on to the hierarchy of clusters. Dendrogramix enables users to do tasks which involve both clusters and individual objects that are impracticable with the classical representation, like: to explain why a particular objects belongs to a particular cluster; to elicit and understand uncommon patterns (e.g., objects that could have been classified in a totally different cluster); etc. Those sensemaking tasks are supported by a consistent set of interaction techniques that facilitates the exploration of large clustering results.

Understanding Hand Degrees of Freedom and Natural Gestures for 3D Interaction on Tabletop

Interactively creating and editing 3D content requires the manipulation of many degrees of freedom (DoF). For instance, docking a virtual object involves 6 DoF (position and orientation). Multi-touch surfaces are good candidates as input devices for those interactions: they provide a direct manipulation where each finger contact on the table controls 2 DoF. This leads to a theoretical upper bound of 10 DoF for a single-handed interaction. With a new hand parameterization, we investigate the number of DoF that one hand can effectively control on a multi-touch surface. A first experiment shows that the dominant hand is able to perform movements that can be parameterized by 4 to 6 DoF, and no more (i.e., at most 3 fingers can be controlled independently). Through another experiment, we analyze how gestures and tasks are associated, which enable us to discover some principles for designing 3D interactions on tabletop.

Gesture-based design of 2D contours: an alternative to sketching?

In addition to being a very expressive media, 2D sketches representing the contour of a shape are commonly used as a basis for 3D sketch-based modeling. This paper investigates an alternative to the standard way of creating such sketches: instead of carefully following the contour with a pen and erasing or over-sketching, the user progressively shapes the contour from a simple input curve, only through intuitive deformation gestures. No menus or sliders are used. This is achieved by providing an automatic selection mechanism between a minimal set of deformation operators, inspired from Michael Leytons perceptual theory of shapes. The shape representation and the active operator parameters are kept transparent to the user. This enables user to focus on the design and makes the system immediately usable by anybody. We validate this new paradigm through a user study that includes a comparison with standard sketching.

Treemaps zoomables: techniques d'interaction multi-échelles pour les treemaps

Some efficient visualizations (such as treemaps) have been proposed for trees, but the interaction they provide to explore and acces data is often poor, especially for very large trees. We have designed a consistent set of navigation techniques that makes it possible to use treemaps as zoomable interfaces. We introduce structure-aware navigation, the property of using the structure of the displayed information to guide navigation, property that our interaction techniques share.

TraceViz: a visualization framework for interactive analysis of execution traces

Hardware platforms of embedded systems are more powerful at each new generation thank to the integration of System-on-Chip (SoC). Developing streaming multimedia applications on embedded systems becomes an increasingly complex process. Modern applications are highly multi-threaded and have to decode the multimedia stream in real time to prevent the apparition of audio and video artifacts. Debugging this kind of issue cannot be done with traditional debuggers that interrupt the decoding and perturb the synchronization of the different threads. The solution is to record all the events that occurred during the decoding in a trace and perform the analysis post-mortem. There exists many visualization tools to analyze execution traces but they have reached their limits with the amount of data generated by modern applications. They either provide a too generalized representation to be useful, or they show too much details leading to a fastidious data exploration. We propose a novel interaction visualization framework to address these problems. In particular, our contribution is in two parts: (a) we present a new fast backend suitable for the interactive browsing of huge traces and (b) a new visualization tool to explore the trace at different level of details.