For a visualization to be considered interactive, it must satisfy two criteria:
- Human input: The control of some aspect of the visual representation of information must be available to humans
- Response time: The changes made by humans must be incorporated into the visualization in a timely manner
When large amounts of data must be processed to create a visualization, this becomes very hard, sometimes impossible, even with the current technology; therefore, "interactive visualization" is usually applied to systems that provide feedback to the users within several seconds of input. Many interactive visualization systems support a metaphor of navigation, analogous to navigation through the physical world.
The benefit of interaction is that people can explore a larger information space in a shorter time, which can be understood through one platform. However, a disadvantage to this interaction is that it requires a lot of time to exhaustively check every possibility to test the visualization system. Moreover, designing systems to guarantee immediate response to user actions can require significant algorithmic attention.
Any visualization method needs a good plan of layout. Some layout methods automatically lead to symmetrical drawings; alternatively, some drawing methods start by finding symmetries in the data. Interactive visualization is implemented using event listeners, and to some, this is well understood as common knowledge, but in any case, the following section describes what it is all about.
An event listener is a process that is used when a mouse is either moved or clicked. Technically, there are many kinds of events, but purely for interactive visualization, you need to only know what happens when the user navigates through the visualization with the mouse. The latency of interaction, that is, the time it takes for the system to respond to the mouse action, matters immensely.
The most obvious principle is that the user should indeed have some sort of confirmation that the action has completed, rather than being left dangling wondering whether the action is still in progress. Thus, feedback such as highlighting a selected item is a good way to confirm that the desired operation has completed successfully. Visual feedback should typically take place within the immediate response latency class of around one second. The following is an example of a JavaScript event listener in Google Charts:
chart = new google.visualization.PieChart(document.getElementById( 'chart_div'));
google.visualization.events.addListener(chart, 'select', selectHandler);
chart.draw(data, options);
function selectHandler() {
var selectedItem = chart.getSelection()[0];
var value = data.getValue(selectedItem.row, 0);
alert('The user selected ' + value);
}Another principle is that if an action takes significantly longer than a user would naturally expect, some kind of progress indicator should be shown to the user. It is much easier to write event listeners in JavaScript, but in order to create an interactive visualization using plotting methods written in Python, one should use Plotly.
There is another module, graph-tool (https://graph-tool.skewed.de), that can be harnessed to perform animations in a straightforward manner. It uses GTK+ to display animations in an interactive window as well as off-screen to a file. The idea is to easily generate visualizations, which can be used in presentations and embedded in websites.
In order to display data visually and efficiently, it is very important to know the layout methods. Aesthetics is one of the criteria that measures the strength and weakness of the layout algorithm. In order to make the layout results more readable, the structure needs to have either an hierarchy or a symmetry, if possible; one critical factor is the utilization of space.
A good layout is essential for untangling and understanding any graphic. Generally, each layout is uniquely suited to different kinds of data visualization in order to be best understood. A few notable layout methods are as follows:
- Circular layout
- Radial layout
- Balloon layout
Tables are natural containers for data. Whenever information is presented, chances are very high that it is presented by means of a table. In many cases, however, when this information is complex (and the table, therefore, is large), a tabular presentation is difficult to parse visually and the patterns in the tabulated data remain opaque.
In other words, a useful container is not always a useful way to present data. The table presents individual data very well, but their inter-relationship and the patterns that they compose are hardly visible. A circular layout can use several different combinations (qualitative and quantitative) to be displayed in a single visualization as shown in the following image:
For instance, it is intuitive to display a complex relationship within a limited space as shown in the preceding image.
The preceding image shows an example of a complex hierarchical relationship displayed in a circular layout.
Sunburst visualization is a radial space-filling visualization technique for displaying tree-like structures (as shown in the preceding image). There are other space-filling visualization methods that use other visual encodings for describing hierarchies. For example, the treemap is a space-filling visualization that uses "containment" to show "parent-child" relationships. There are a couple of subtle changes that can improve the way the information is communicated by this visualization.
Since the length of each orbit increases with the radius, there tends to be more room for the nodes. A radial tree will spread the larger number of nodes over a larger area as the levels increase.
