Spatial Layout

From CS294-10 Visualization Sp11

Revision as of 01:29, 19 March 2011 by Matthew Can (Talk | contribs)
(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation, search

Lecture on Mar 14, 2011




Same readings as for Using Space Effectively: 2D II lecture. However, you are still responsible for making a comment on this lecture.

  • A general cartographic labeling algorithm, Edmondson, Marks & Shieber (pdf)
  • A survey of automated layout techniques for information presentations, Lok and Feiner (pdf)
  • Dynamic space management for user interfaces, Bell & Feiner (pdf)

Optional Readings

  • Rendering effective routemaps, Agrawala & Stolte (pdf)
  • Artistic resizing, Dragicevic et al. (pdf)
  • Adaptive grid-based document layout, Jacobs et al. (acm)
  • Map labeling bibliography


Dan - Mar 14, 2011 02:04:46 pm

I like the network layout constraints as that part was easy to see how it could work in theory and implementation. It reminds me a lot of the CSS box model or the DOM Object model. The constraints as linear equations seems to be a great interface for coding such interfaces. A GUI could be cumbersome and also a coding interface like this provides the ability for automation. The adaptive layout was also good because it demonstrates that you can use various templates and switch between them for various user interactions involving resizing the window. However, it can be improved by dynamically generating the templates instead of having to have a user that manually creates then in a GUI. Simulated annealing was an interesting algorithm for ways of generating layouts. I like the randomized placement with the perturbing of elements and associated penalties. It seems you could in fact use combinations of the above algorithms in conjunction with simulated annealing to get what you are looking for in particular visualizations. For example, adding constraints in the form of linear equations that are set up by a user and then running a simulated annealing algorithm.

David Wong - Mar 15, 2011 03:41:05 am

I enjoyed today's discussion about rule-based and constraint-based layout techniques. The DAG network model of constraints reminded me of the bindable property thats available in Flex. Essentially, when you bind an object's property value to another variable, whenever that variable's value changes, the object's property value will update accordingly. For example, you can bind the height of one object to the height of another so that they scale dynamically together without too much code overhead. While this is a very handy variable property to utilize, it also introduces bugs in Flex if you happen to redefine the property value so that it is no longer bound to a certain variable, illustrating the difficulty in maintaining these constraints (at this level in the compiler).

I am interested in hearing more about learning based approaches to layout constraint problems. It seems that this could become an interesting crowdsourcing problem, similar to GWAP. If the crowd can identify good layouts, you can amass enough data to properly train a layout constraint learner.

Saung Li - Mar 15, 2011 04:31:41 am

I was intrigued by the automation of labeling visualizations such as timelines shown in class. I did not know that such algorithms existed, but it is not surprising since we work with such data all the time and certain patterns can be used to automate the labeling. Of course, automating labeling is not always perfect, so allowing the user to modify the labeling before and after running the algorithm is a good example of users working together with computers to work. The automation sets up standards that save time, and at the same time having an algorithm that allows users to make modifications provides flexibility. I found the example of the automated window layout to be quite fascinating as well. The algorithm dynamic readjustment of boundaries is quite smooth and could be applied to many cases where we would like to organize objects together. It would be interesting to see examples of laying out 3d objects, as this could be useful as well.

Jvoytek - Mar 15, 2011 01:30:01 pm

The automated layout by Microsoft research seems to be a step in the right direction. The results were impressive when the templates were created by talented individuals. I wonder if additional and intelligent constraints could be implemented by default (maybe that could be overwritten by expert users) to improve the initial quality of the templates created with the system...

Michael Cohen - Mar 15, 2011 02:10:51 pm

I liked the concept behind the Bell & Feiner paper (and thought it was explained well) but their system seems to me to be a solution looking for a problem. In real-life use of window managers, it's rare that all my windows are small enough to have all on the screen at once, regardless of how well the space is managed; windows large enough to do real work in often require more space, and that necessitates overlap (or more monitors!). The medical record example was somewhat more compelling in that the use of free space allowed the overview and detail views to remain visible at the same time. However, that example creates a bit of an artificial problem by using such an information-sparse overview; it seems that the overview could just as easily be fit into a small band at the bottom of the screen, leaving the entire midsection available for the detail view. In fact, it seems that this would be necessary if the density of records were any higher. In general, I'm not convinced that there are very many displays with a density that would benefit from their algorithm... and if the displays do have a density that low, we might ask whether the free space could be used better by the elements already present!

Krishna - Mar 15, 2011 03:10:57 pm

My main takeaway from this lecture is that all the automatic layout algorithms have a set of constraints that is given as an input, a procedure to generate (or) update a layout and finally, a criteria that measures the quality of the generated layout. The constraints can be hand-crafted, can be defined by an optimization process, can be learnt from a set of examples and can be continuously updated using feedback from the users. I believe an important addition to this list is to learn the constraints from the data itself. The classic examples are graph layout algorithms. For example, LinkedIn's InMap: [1] uses a community detection algorithm to layout the social network - thus it is primarily data driven although additional layout mechanics are needed to decide on the position and spacing of the communities and the vertices themselves.

Sally Ahn - Mar 15, 2011 11:52:50 pm

Looking at Figure 12 in Bell and Feiner's Dynamic Space Management paper got me to thinking about nested windowing systems. I think allowing users to group windows by task (similar to grouping apps on the iPhone), then applying the 2D layout algorithms to these "group windows" might be a useful system. As Michael points out, one limitation of the layout system is that it manages lots of small windows, but not large windows, which are often needed for many computer tasks. With nested windows, I am imagining a screen with a large area devoted to the "work window" and a side panel of smaller "group windows" that contain individual windows grouped by task. The idea would be to automatically group windows by task and lay the small thumbnail versions of the individual windows in a smart way to allow the user to quickly switch from one task to another, possibly by updating the large "work window." I wonder if such a system exists already; this was just a thought that occurred to me while looking at the Bell and Feiner's Window manager testbed.

Thomas Schluchter - Mar 15, 2011 10:32:43 pm

I liked the Bell and Feiner paper for its extensive use of pseudocode and graphical examples. It really made the concept clear, and the rationale for the algorithm was well developed. In a way, this got me thinking about how algorithms are represented in general. A lot of the CS papers that I had the pleasure to read seem to hide a lot of information behind abstract language and mathematical formulae. Granted, the approach in this paper lent itself to a graphical representation because the problem was inherently spatial, but I think the authors did an excellent job of visualizing the algorithm's workings.

Like others mentioned before, the window manager doesn't seem to be the best application for this kind of white-space minimization. One area where I think this would be very useful is in storage management -- a common problem is to combine containers of varying sizes in a limited physical space, resembling the Tetris problem in the real world. This kind of computing LES could be a really handy way of planning the positioning of containers.

Michael Hsueh - Mar 15, 2011 10:56:29 pm

Artistic resizing is a great idea. The variety of screen sizes on devices used to access web content is larger than ever and tailoring layouts to accommodate is formidable. I think supporting manual intervention in layout tasks is important. For example, with exocentric labeling, superior results can be obtained if the user is allowed to manually place and restrict certain labels. Ultimately, it is really a fancy way for a user to specify layout constraints via a GUI. This basic concept is an important component of my MS research on introducing user interactivity to automated OCR pipelines.

Karl He - Mar 16, 2011 03:18:20 am

I find the Excentric labels demo and similar examples to be particularly interesting, as they are related to an idea I had for a final project (but didn't end up pursuing). Having a good labeling system allows visualizations to more dense than would normally be human readable. For example, two points on scatterplot which overlap would normally be impossible for a person to read, but with something like the excentric labels, you would see based on the labels that there are actually multiple points present. It allows for providing extra information when a focus is needed, but not cluttering the visual as a whole.

Brandon Liu - Mar 16, 2011 05:46:58 pm

After browsing aroung the internet a bit, I noticed that the 'solution' to the labeling problem on most maps is simply adding a numbered marker, and then puting the details on the marker in a sidebar. I'm curious if there have been any quantitative user studies to show if the techniques in the readings such as excentric labeling are really any better. One limitation of the numbered marker strategy is that only 10-12 labels can be shown at a time without being overwhelemed.

Julian Limon - Mar 16, 2011 08:48:01 pm

I had never thought of the difficulties of labeling until Jeff Heer mentioned it in class. Since then, I have been looking at the kinds of labels that are common in most visualizations. It seems that labels are a liability that designers need to carry through their design. There isn't a lot of innovation or creativity on making use of text to tell a better story. Techniques like excentric labeling do address the problem, but also as a liability that needs to be presented in a very scarce space. I'd love to see more research or tools that do interesting things with labels, so if you know of any examples, please let me know!

Matthew Can - Mar 18, 2011 07:58:34 pm

The Lok and Feiner paper provides a nice overview of some of the challenges of automated layout. Regarding the constraint satisfaction approaches, the paper mentions two kinds of constraints, abstract and spatial. The paper argues that spatial constraints are necessary to generate layouts with aesthetic appeal (that conform to design principles). And in fact, the high level abstract constraints must be translated into spatial constraints before the layout process. This makes me wonder why an automated layout system would ever bother to explicitly support abstract constraints. The only reason I can think of is that there are some spatial constraints that are commonly used together and that have some semantic meaning as a group. For the user's convenience, the system bundles these sets into abstract constraints. But if this is the case, it might be better just to let the user define her own abstract constraints.

[add comment]
Personal tools