Paul Keir

Gesture-recognition with Non-referenced Tracking

This paper presents 3motion, a novel 3D gesture interaction system consisting of a low-cost, lightweight hardware component and a general-purpose software development kit. The system provides gesture-based 3D interaction for situations where traditional tracking systems are too expensive or impractical due to the calibration and reference source requirements. The hardware component is built around a 3-axis linear accelerometer chip and transmits a continuous data stream to a host device via a wireless Bluetooth link. The software component receives this data and matches it against a library of 3D gestures to trigger actions. The system has been validated extensively with various example applications, including a “Battle of the Wizards” game, a character manipulation demonstrator, and a golf game implemented on a mobile phone.

Gameplay issues in the design of spatial 3D gestures for video games.

We describe preliminary tests that form the first phase of research into issues involved with the design of spatial 3D gestures for video games. Early research on 3D gesture and spatial interaction was largely the domain of Virtual Reality (VR) [1]. More recent work looks at 3D gestures for mobile devices [2] and pervasive computing [3]. We are investigating issues affecting usability and fun [4] in the context of 3D gestures and spatial movement in video games where emotion, immediacy and immersion are more important than breadth of functionality and user task efficiency. These tests use our 3motion™ system, a wireless inertial motion tracking device and gesture SDK. This enables a range of gesture types from tight, precise movements to whole arm gestures, and from direct mapping of movement to recognition of 3D symbolic gestures. Four game scenarios using different spatial gesture characteristics were used to identify gameplay issues that have an impact on the design of 3D interaction.

Kernel composition in SYCL

Parallel primitives libraries reduce the burden of knowledge required for developers to begin developing parallel applications and accelerating them with OpenCL. Unfortunately some current libraries implement primitives as individual kernels and so incur a high performance cost in off-chip memory operations for intermediate variables. We describe a methodology for creating efficient domain specific embedded languages on top of the SYCL for OpenCL standard for parallel programming. Using this approach, a small example language was developed which provides an environment for composing image processing pipelines from a library of more primitive operations, while retaining the capability to generate a single kernel from a complex expression, and so eliminate unnecessary intermediate loads and stores to global memory. This elimination of global memory accesses leads to a 2.75x speedup over implementing an unsharp mask in OpenCLIPP. We give details of our domain specific embedded language, and provide experimental performance measurements of both primitive performance and an unsharp mask operation composed of multiple primitives.

Array languages and the N-body problem

This paper is a description of the contributions to the Scottish Informatics and Computer Science Alliance Multi‐core Challenge on many body planetary simulation made by a compiler group at the University of Glasgow. Our group is part of the Computer Vision and Graphics research group, and we have for some years been developing array compilers because we think these are a good tool both for expressing graphics algorithms and for exploiting the parallelism that computer vision applications require. We shall describe experiments using two languages on two different platforms, and we shall compare the performance of these with reference C implementations running on the same platforms. Finally, we shall draw conclusions both about the viability of the array language approach as compared with other approaches used in the challenge and also about the strengths and weaknesses of the two, very different, processor architectures we used. Copyright

Programming heterogeneous multicore systems using threading building blocks

Intels Threading Building Blocks (TBB) provide a high-level abstraction for expressing parallelism in applications without writing explicitly multi-threaded code. However, TBB is only available for shared-memory, homogeneous multicore processors. Codeplays Offload C++ provides a single-source, POSIX threads-like approach to programming heterogeneous multicore devices where cores are equipped with private, local memories--code to move data between memory spaces is generated automatically. In this paper, we show that the strengths of TBB and Offload C++ can be combined, by implementing part of the TBB headers in Offload C++. This allows applications parallelised using TBB to run, without source-level modifications, across all the cores of the Cell BE processor. We present experimental results applying our method to a set of TBB programs. To our knowledge, this work marks the first demonstration of programs parallelised using TBB executing on a heterogeneous multicore architecture.

Towards programmable address spaces

High-performance computing increasingly makes use of heterogeneous many-core parallelism. Individual processor cores within such systems are radically simpler than their predecessors; and tasks previously the responsibility of hardware, are delegated to software. Rather than use a cache, fast on-chip memory, is exposed through a handful of address space annotations; associating pointers with discrete sections of memory, within trivially distinct programming languages. Our work aims to improve the programmability of address spaces by exposing new functionality within the LLVM compiler, and then the existing template metaprogramming system of C++. This is achieved firstly via a new LLVM attribute, ext_address_space which facilitates integration with the non-type template parameters of C++. We also present a type traits API which encapsulates the address space annotations, to allow execution on bath conventional and extended C++ compilers; and illustrate its applicability to OpenCL 2.x.

3motion: untethered 3D gesture interaction

The 3motion system enables the recognition of gestures based on 3D trajectories in space. It consists of both a software and a hardware component. The Software Development Kit (SDK) enables programmers to implement and control how they want to recognise movements in space such as a punch, a golf swing, a baseball pitch or even a dance move. Although the SDK can work with any positioning device from a 2D mouse to a 6 degree of freedom tracker we have developed our own low-cost hardware to provide wide-range wireless functionality. The main innovation of the 3motion system is the combination of a 3D curve matching algorithm with acceleration signatures from inexpensive inertial sensors.