Project offerings 2011
Projects supervised by Anthony Collins and Judy Kay
One touch or more - a change for interaction design on touch surfaces
Emerging touch interfaces, including phones and embedded surfaces computing on walls and tables, creates new possibilities for interaction, as well as new limitations. This project explores one tightly defined aspect that has not had the attention it deserves: whether and when to use multi-finger gestures and when not to. For example, to enlarge an object, the emerging gesture involves two-fingers, as on the iPhone and the Microsoft Surface. By contrast, our own Cruiser framework provides a one-finger resize action.
The project can take one of two directions: a technical focus, which will involve adding support for multi-touch gestures to our existing Cruiser framework (e.g. for two finger pinch resizing), and providing a general framework for plugin designers to easily take advantage of multi-touch gestures. The other direction focuses on an evaluation. This will involve an analysis of the literature of multi-touch gestures, and a detailed user study to compare approaches (e.g. comparing Cruiser's single-finger rotate/resize gesture, with the now ubiquitous two finger 'pinch').
Required skills:
Technical focus: Strong programming skills in C/C++, interface design, OpenGL experience desirable but not essential
Evaluation focus: interest in learning user study methodologies (guidance provided), strong analytical skills
Students interested in this project should have a strong background in either of these areas and the project can be tailored to match any particular strengths.
For more information on the Cruiser tabletop framework (including video), see the project website.
Gesture learnability for beginner users of tabletops and interactive walls
Interactive tabletops are starting to appear in many social environments, such as public kiosks in museums and large buildings, and they will also eventually be found in homes, schools and workplaces. The novelty of the tabletop means that there will often be people who have never used one before. Therefore, the tabletop interface design should take account of the varying levels of experience of the users. This project explores ways to improve learnability of tabletops and other similar interfaces, such on touch interfaces projected on walls. These devices typically have a range of gestures (such as a two finger 'pinch' gesture to resize images), but unless these gestures are first demonstrated to the users, they may not know that the gestures exist at all. In essence, current tabletops do not support exploration of the available interface 'actions' (for example, cut, copy and paste). By contrast, conventional desktop user interfaces have menus and toolbars that the user can explore to learn the available actions. With the move to gesture-based interfaces, it is difficult to learn the available gestures (unless an expert user is present to demonstrate them), and they are easy to forget. Thus, we need a way to help users discover and learn gestures, with the system supporting the user according to their level of familiarity.
This project explores this broad issue and can focus on one of two aspects. The technical implementation will involve adding an interactive tutorial mode to our Cruiser framework, to help users discover the available gestures and to give them feedback as they complete them (for example, to help a user if they get stuck while performing a gesture). You will also look at how gesture learnability can be improved for such devices that are located in public spaces (such as on a building wall), with many first-time users.The other aspect focuses on an evaluation of gesture learnability for tabletops. This will involve an analysis of the literature of gesture learnability, and a detailed user study to determine the ideal gesture-sets for beginner and experienced tabletop users, and also the ways to convey these gestures to users for learning them at a tabletop.
Required skills:
Technical focus: Strong programming skills in C/C++, interface design, OpenGL experience desirable but not essential
Evaluation focus: interest in learning user study methodologies (guidance provided), strong analytical skills
Students interested in this project should have a strong background in either of these areas and the project can be tailored to match any particular strengths.
For more information on the Cruiser tabletop framework (including video), see the project website.
Flexible grouping mechanisms for tabletop interfaces
Interactive tabletops are well suited to collaborative work, as a small group of users can all interact at the shared surface, at the same time. However, having multiple users increases the challenge of clutter. With multiple people using the tabletop, they might create and interact with artefacts that overlap both shared and individual objects, particularly when artefacts are enlarged for a more detailed view. In a multi-user setting, where multiple people are creating and interacting with content on the tabletop simultaneously, management of clutter becomes challenging - existing methods to manage clutter in conventional personal computers, such as a 'task-bar' in a window manager to control active windows, were only designed for single user interaction. The management of clutter by one user could also have unintentional and adverse affects on other users of the tabletop. This project explores gestures to organise and sort information on the tabletop. Some tabletop hardware is single-touch, and some is multi-touch. Different gestures for organising information may be more effective on certain kinds of hardware.
In this project you will concentrate on one of two areas. The technical track will involve implementing gestures to organise the information on the tabletop. For example, one approach you might explore is a lasso gesture for quickly grouping a set of objects on the table, and then a menu could appear for the user to select between different sorting and filtering options. Alternatively, a faceted tag browsing interface could be used to navigate the different objects on the screen. The evaluation track explores the effects of and approaches to managing clutter on tabletops. This will involve an analysis of the literature on the existing approaches to managing clutter, and a detailed user study will compare some existing approaches (in the existing tabletop interfaces) to determine the most effective ways to reduce and manage interface clutter at multi-user tabletops.
Required skills:
Technical focus: Strong programming skills in C/C++, interface design, OpenGL experience desirable but not essential
Evaluation focus: interest in learning user study methodologies (guidance provided), strong analytical skills
Students interested in this project should have a strong background in either of these areas and the project can be tailored to match any particular strengths.
For more information on the Cruiser tabletop framework (including video), see the project website.
Making the tabletop personal: employing user models to aid information retrieval at interactive surfaces
Tabletops have the potential to provide an excellent interface for people to explore information at public venues like museums, especially if the information delivery can be personalised, to match the user's interests. This project investigates the application of user modelling to an interactive tabletop, where a user can easily provide an existing model of their interests to a tabletop, and this drives the personalisation of information presented. For example, the user might carry a smartphone that contains their user model (a representation of their interests and level of knowledge for those interests), and placing that phone on the tabletop might change the display of the show information matching the user's interests. For example, a user could walk around a museum and take snapshots of QR codes at exhibits that interest them, to mark information as interesting in their user model. Walking up to the tabletop and placing the phone on the tabletop enables personalisation, highlighting the information that interests the user. At the end, the tabletop could send a summary of the user's visit to their email address, and have the exhibits they visited added to their visit history. Another application domain is news reading at a tabletop, where the news articles displayed can be tailored to match the user's interests.
This user modelling concept can also be used for more than personalisation of tabletop content (e.g. files). Shared tabletops face the challenge of enabling customisation by a range of users, where the tabletop is configured to behave in a particular way based on a user's skills and preferences. A desktop can be customised and organised how a user wants, but at a shared tabletop, different users have different preferences. Bringing this user model concept to the tabletop would enable a user to walk up to a table and place their phone on it (or send their user model to it), in order to load their tabletop configuration settings; this alters the behaviour of the tabletop while they are using it (for example, if the user is experienced it could enable some sophisticated gestures for working with the objects on the table).
You will investigate one of two aspects. The technical aspect will involve creating the infrastructure and tabletop interface for enabling the user to load their user model from a phone, to customise the display of information on the tabletop. Thus, the project will involve an integrated mix of smartphone and tabletop programming. As well as integrating with the phone, you will explore ways to customise the display of content, and customise the behaviour/configuration of the tabletop, based on the user models. The evaluation aspect involves conducting a field-based user study (e.g. in a museum context) with our existing ShowMe tool, which stores a user model on the user's smartphone - they can then send that model, called a 'persona', to the tabletop to personalise the information displayed.
Required skills:
Technical focus: Strong programming skills in C/C++, Java (Android) and/or Objective-C (iOS) knowledge desirable, interface design, OpenGL experience desirable but not essential
Evaluation focus: interest in learning user study methodologies (guidance provided), strong analytical skills
Students interested in this project should have a strong background in either of these areas and the project can be tailored to match any particular strengths. For more information on ShowMe, see the project website.