NodeBeat was created by Seth Sandler and Justin Windle earlier this year and released in April for the iOS platform. It is an experimental node-based audio sequencer and generative music application. By combining music and playful exploration, NodeBeat allows anyone to create an exciting variety of rhythmic sequences and ambient melodies in a fun and intuitive fashion.

How Does it Work?

Octaves and Notes make up the two types of nodes. Octaves pulse and send messages to Notes within proximity. Each Octave is assigned a random octave and each Note, a random note; therefore, a Note will play in several octaves depending on the Octave it’s connected to. Pause nodes to create your own beats or let them roam free to have them generate their own.

Cross platform development

Because NodeBeat was developed using the C++ based open source framework openFrameworks, I did not expected a lot of trouble getting the core to work on Android. However, since the Android port of openFarmworks is still pretty new (we’re using the development branch) and officially only supported on the Mac and Linux platforms, I decided to put some effort into making it work on Windows as well. I’m a Windows user and developer, so if I can avoid dualbooting, I will .

Native Development Kit

As soon as you want to use C or C++ in your Android projects, you will have to install the Native Development Kit (NDK). It basically allows you to compile your code into a library which you can access using JNI calls. While in general it is recommend to code using the SDK in Java for your Android projects (the Dalvik VM with JIT show really good performance), lazy coders (like me ) are always trying to find ways to reuse existing code. Instead of having a native codebase for iOS (in Objective-C) and Android (in Java), it is nicer to have a shared core in C++ with a thin layer (Obj-C or Java) to interface with it. Sure the NDK might sound intimidating at first sight and Google doesnt recommend it unless you know what you’re doing, but honestly I don’t think its rocket science either. After downloading the NDK, you will need to setup a unix like environment such as MinGW or Cygwin.

For my previous projects I already had MinGW installed (you could use Cygwin, but in general I don’t like their approach). I did a fresh checkout from Github and started to mess around with the Makefiles to see if it would compile.

It turned out that all I had to do is replacing a few IF statements (the ones that are checking the build platform) and make them point to the NDK location on my Windows computer. I’ve created a tutorial that explains the steps if you want to try it out yourself. However, if you want to use openFrameworks for your own Android applications, I would highly recommend just using my openFrameworks fork instead (until they accept my pull request). It includes all the patches from the tutorial and it should be compatibly with the latest NDK. The tutorial actually also explains how to run one of the examples so be sure to check that out.

Porting the GUI

For the UI I wanted to stay as close to the iOS version as possible. As I don’t own an iOS device, Seth gave me some screenshots of NodeBeat running on iOS which I used as a reference.

Since the iOS and Android framework are quite distinct, there are cases where I had to do an alternative implementation. For example, on Android most devices have the following buttons:

• Back
• Menu
• Home
• Search

1
2
3
4
5
6
7
8
9
10

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:id="@+id/node"
          android:icon="@drawable/node_icon"
          android:title="Node" />
    <item android:id="@+id/audio"
          android:icon="@drawable/audio_icon"
          android:title="Audio" />
          ...
</menu>

Example: Audio menu

Example: Recording dialog

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setMessage("You can stop recording by pressing the record button in the menu again")
       .setCancelable(false)
       .setPositiveButton("Yes", new DialogInterface.OnClickListener() {
           public void onClick(DialogInterface dialog, int id) {
                // Start recording
           }
       })
       .setNegativeButton("No", new DialogInterface.OnClickListener() {
           public void onClick(DialogInterface dialog, int id) {
                dialog.cancel(); // Cancel dialog
           }
       });
AlertDialog alert = builder.create();
alert.setTitle("Start recording");

Using JNI Callbacks

After we’ve ported the UI, we still need to pass on our settings to the core application. Fortunately we can use JNI callbacks to get and set NodeBeat’s properties. It is good to know that you should minimize the number of JNI callbacks for performance reasons (so don’t go mental and call tons of JNI methods each time you render a frame).

Let say we would like to pass a value from one of the sliders from the Audio context menu to our NodeBeat core. In such case we first create a new static method in our Java source file:

OFActivity.java

1

public static native void sliderChanged(float v);

It is important to use the static and native keyword when you define your method. This is all we need to do in our java code and this method can be used anywhere in our java class.

Now the tricky part is how to implement the function on the C++ side of your application. It’s not exactly complex, but you will have to pay attention to a few details. Three things are important here:

1. The namespace (in Java)
2. The class name
3. The method name

If we assume we’re implementing this callback in one of the openFrameworks examples, this means:

1. The namespace (in Java): cc.openframeworks.androidEmptyExample
2. The class name: OFActivity
3. The method name: sliderChanged

main.cpp

Here is the code you implement in C++

1
2
3
4
5

#include <jni.h>
extern "C"{
void Java_cc_openframeworks_androidEmptyExample_OFActivity_sliderChanged (JNIEnv*  env, jclass  thiz, jfloat value){
// Do smth here
}

As ugly as this method looks like, take a brief look at how it is constructed. It starts with the return type (which is void just like how we specified it in Java). Next it starts with Java_ and is succeeded by the namespace, classname , method name. All dots from the namespace are replaced by underscores and between each element we place an underscore as well.

In the arguments list, the “JNIEnv*  env, jclass  thiz” part is mandatory (so if you have a something like this: public static native void methodname(), it would be void methodname(JNIEnv*  env, jclass  thiz)). For our method we want to pass a float as argument. For some reasons you can’t just pass a float, you will need to use JNI mapping types. The float becomes a jfloat.
Note: for booleans you need to compare the value to JNI_TRUE or JNI_FALSE and not to true or false.

Honeycomb Tablets

Unlike the iOS devices from Apple, Android devices run at so many different configurations and API levels, it can be a bit tricky to support all of them. For NodeBeat we decided to create two versions: A phone version and tablet version. We basically distinguish between phones who are running Eclair or Gingerbread (2.2+) and tablets running Honeycomb (3.0). On the Android Market it seems like we only provide one version, but depending on what device you’re using to download the app, it will give you a certain version.

In order to maximize the use of the display, I’m using this line in the AndroidManifest.xml file:

1

android:theme="@android:style/Theme.NoTitleBar.Fullscreen"

On phones it sets the application to fullscreen. While this works for anything running Android 2.2+, it is a problem on Honeycomb devices. Honeycomb tablets don’t have any physical buttons and when the application is running in fullscreen mode, there is no shortcut to the menu button. This shortcut is normally placed in the top right corner.

This means that for the tablet version, we run the application in regular display mode.
Other than that, NodeBeat provides a rich user experience on tablet devices such as the XOOM or Asus transfomer.

Earbleeding masterpiece created by Sharath Patali (professional coder, horrific musician)

Android Market

Publishing the app to the Android market is no hassle at all (we were just a bit unfortunate and had our app pulled down by accident). There is no annual fee (just a one time 25$) and apps are approved instantly. The dev guide provides a comprehensive overview on how to build your project in release mode and how to sign it.

Go get it!

NodeBeat is available on the Android market:
https://market.android.com/details?id=com.AffinityBlue.NodeBeat

Try it out! It’s just a dollar

Website: http://nodebeat.com/
Twitter: http://twitter.com/NodeBeat

Recently I started to organize the footage I made and collected over the years and decided to put some of it online. To maintain the overview, a new section has been added to the site: Research Projects. It includes most of the projects I have been working on at the University of Amsterdam (UvA) and Harvard University.

Each project includes a short description, pictures and a video. Enjoy!

(Click the project title for more information)

Interactive Networks

This project introduces the Interactive Network concept and describes the design and implementation of the first prototype.

Twilight

Twilight is an interactive graph exploration tool for multi-touch systems. Twilight provides a flexible environment that can be used to visualize and analyse graphs and networks found in the computational science.

Treepanorama

This projects involves the visualization of large phylogenetic tree structures such as the ones found in the Tree of Life. By combining high performance computer graphics with multi-touch input interaction methods, his project will create an interactive exploration environment that allows us to view the data interactively and in different representations. This research will lead into a better understanding of the evolutionary tree.

Involv

INVOLV is a research project that combines cutting-edge interactive technology with emerging information visualization techniques to create innovative explorations for large hierarchical data sets

Phylogenie

This application is designed to be a collaborative activity to teach undergraduate students about phylogeny and to prevent misconceptions about evolution. The system guides the students through a set of steps required to construct a phylogenetic tree based on morphological and DNA sequence data.

Since this project is still active, more media content will be released in future!

* update: 27 November 2010 *

Old footage from personal projects: Touch tracer and Real time fluid dynamics running on the UvA-MTT

Touch Tracer v0.3

Real time fluid dynamics

Seth Sandler a good friend of mine, released his new website sparkon.net which is a website that he describes as “a social platform for people that are sparked (inspired) by creative and emergent technology”.

Personally I like the way how he organized the site. Basically he created a portal that allows you to rapidly find (multitouch) applications, open source programming frameworks, and community projects that are out there, all in one single place!

Check it out and don’t forget to add your own projects as well!

Interactive Tabletops and Surfaces 2010

If you’re doing research on interactive tabletops and surfaces, you might want to check out this years ITS 2010 conference. This year it will be hosted in Saarbrücken, Germany!

Check out the details below (more information after the break).

CALL FOR PARTICIPATION

5th Annual ACM Conference on Interactive Tabletops and Surfaces 2010

ITS 2010
November 7-10, 2010
Saarbrücken, Germany

http://www.its2010.org
————————————————————————-

The Interactive Tabletops and Surfaces 2010 Conference (ITS) is a
premiere venue for presenting research in the design and use of new
and emerging tabletop and interactive surface technologies. As a new
community, we embrace the growth of the discipline in a wide variety
of areas, including innovations in ITS hardware, software, design, and
projects expanding our understanding of design considerations of ITS
technologies and of their applications.

Building on their success in previous years, ITS again features Papers
and Notes presentations, as well as tutorials, posters, and
demonstrations tracks. For the first time, ITS 2010 will also include
a doctoral symposium.

ITS 2010 will bring together top researchers and practitioners who are
interested in both the technical and human aspects of ITS technology.
On behalf of the conference organizing committee, we invite you to
begin planning your submissions and participation for this year’s
conference!

CALL FOR PARTICIPATION: PAPERS AND NOTES

The use of interactive surfaces is an exciting and emerging research
area. Display technologies, such as projectors, LCD and OLED flat
panels, and even flexible display substrates, coupled with input
sensors capable of enabling direct interaction, make it reasonable to
envision a not-so-distant future in which many of the common surfaces
in our environment will function as digital interactive displays. ITS
brings together researchers and practitioners from a variety of
backgrounds and interests, such as camera and projector based systems,
new display technologies, multi-touch sensing, user interface
technologies, augmented reality, computer vision, multimodal
interaction, novel input and sensing technologies, computer supported
cooperative work (CSCW), and information visualization.

The intimate size of this single-track symposium provides an ideal
venue for leading researchers and practitioners to exchange research
results and experiences. We encourage submissions on (but not limited
to) the following topic areas as they relate to interactive tabletops
and surfaces:

* Applications
* Gesture-based interfaces
* Multi-modal interfaces
* Tangible interfaces
* Novel interaction techniques
* Data handling/exchange on large interactive surfaces
* Data presentation on large interactive surfaces
* User-interface technology
* Computer supported collaborative systems
* Middleware and network support
* Augmented reality
* Social protocols
* Information visualizations
* Interactive surface hardware, including sensing and input
technologies with novel capabilities
* Human-centered design & methodologies

CONFERENCE COMMITTEE

Conference Co-Chairs
Johannes Schöning
Antonio Krüger

Conference Program Committee Co-Chairs
Daniel Wigdor
Michael Haller

MENTORESHIPS

To help those with less experience in academic publication, ITS 2010
offers the help of our two Mentors Chairs. The mentoring program is
intended primarily for authors from non-academics, including industry.

Two types of help are available from the mentor: assistance in framing
and composing your research paper (early feedback), and help and
feedback reviewing an already completed paper (later feedback). In
either case, the mentor will help frame your work in context of other
related work, and make meaningful suggestions to improve the quality
of your contribution. Both types of mentorship have the same
submission deadline.

Although we cannot guarantee that your submission will be accepted by
ITS, mentoring would be helpful for you to turn your ideas into a
proper research paper. If you wish to avail yourself of this program,
you can do so by sending e-mail to both of the Mentor Chairs Lucia
Terrenghi (lucia.terrenghi@vodafone.com) and Changkyu Choi
(changkyu_choi@samsung.com). The submission type will vary depending
on the type of feedback you are seeking.

Early-Stages Feedback (Deadline: 2010.05.25):

Send a 1-page document describing your intended contribution. This
1-page must include author names and affiliation (e.g. company name),
and enough information for the chairs to understand both what it is
that you have done.

Completed Paper Feedback (Deadline: 2010.05.25):

Send your completed paper to both mentors chairs by May 25.

For both early and paper feedback, you will receive a response by June 14.

SUBMISSIONS
Papers/Notes: We invite paper submissions of two kinds: Papers (10
pages) and Notes (4 pages). Papers must present original, highly
innovative, prospective and forward-looking research, possibly in one
or more of the themes given above. Notes must also report novel and
complete research, but where the scope and scale of the contribution
is more focused and succinct than papers. Submissions must be
submitted as a single PDF file in the ACM format through the
submission system. A template for submissions can be found on the ITS
website (http://www.its.2010.org).

All accepted submissions will be presented at ITS 2010 and appear in
the ITS proceedings and be archived in the ACM digital library.

IMPORTANT DATES

Paper / Note Mentorship Requests (optional): May 25, 2010
Paper / Note Mentorship Feedback Received (optional): June 14, 2010
Paper / Note Submissions: June 23, 2010
Paper / Note Author Notifications: August 27, 2010
Paper / Note Camera-Ready Deadline: October 1, 2010

The calls for the posters, demos, tutorials, and the doctoral
symposium will be published soon, please check our website for further
information.

ITS 2010 Conference: November 7-10, 2010

http://www.its2010.org

I haven’t visited the NEMO for a while (since I’m still in the USA) but my dad visited the science center last month and took these nice pictures:

[Show as slideshow]

Thanks dad!

A few weeks ago I attended TEI’10 hosted at the MIT Medialab.

“TEI, the conference on tangible, embedded, and embodied interaction, is about HCI, design, interactive art, user experience, tools and technologies, with a strong focus on how computing can bridge atoms and bits into cohesive interactive systems.”

To keep it simple, I decided to just posted a lot of media instead of a summary of the TEI ’10 conference… enjoy !

Inspiring projects

Unlike most conferences I have been, this conference was not only a place where scientific work was presented but also where artists could show their work (art meets science).

The following two projects are clearly an example for this:

• SMSlingshot (link contains cool video!) by Patrick Tobias Fischer, Christian Zöllner and Thilo Hoffmann.
• Electronic Popables: exploring paper-based computing through an interactive pop-up book by Jie Qi and Leah Buechley.

Some of my pictures shot at the conference

[Show as slideshow]

12345►

More pictures of the conference

Pictures created by Jean Baptiste Paris on Flickr.

Studio sessions

Pictures created by Seth Hunter of the studio session on surface computing
(I should be in there somewhere…).

Video studio sessions

Nice video compilation of the different studio sessions that took place at the MIT Medialab.

Blog

A blog about the TEI 2010 conference

Keynotes

• John Frazer
• Vik Muniz

Unfortunately I could not attend the conference on interactive tabletop and surfaces, so I missed the great keynotes from: Ken Perlin, Chia Shen and Bill Buxton.
Fortunately a few fellow researchers and friends blogged about the event.

PyMT

PyMT is a python module designed for developing multi-touch enabled applications. The current aim is to provide an environment which allows developers to do quick and easy interaction design, and rapid prototype development.

The projects was initially started by Thomas Hansen but now also contains contributes from: Juan Pablo Hourcade, Sharath Patali, Matiue Virbel, Thiago Serra. Their submitted paper is available in the proceedings from this years conference.

For those who are interested, a nice set of videos demonstrating the toolkits capabilities can be found on Vimeo.

Since it’s open source, everyone can download and contribute to the project. The website can be found here: http://code.google.com/p/pymt/. A nice example of an application created with PyMT by Sharath Patali can be found here: NUIPaint.

TUIO

As one of the designers of the TUIO protocol and the ReacTable, Martin Kaltenbrunner presented his work “reacTIVision and TUIO: A Tangible Tabletop Toolkit” at the conference. For those who are interested, Martin created a nice summary of the conference on his personal blog which can be found here: http://modin.yuri.at/blog/?p=117

More interesting links…

More information about the conference can be found in the topic at the NUI Group forums started by Johannes Schöning (contains some videos and docs), the official youtube channel and on Twitter.

ITS 2010?

Hope to see you next year in Saarbrücken, Germany!

To help out fellow multi-touch users and developers, the NUI Group community decided to create a book sharing information about multi-touch technologies. Originally we intended to release this book during the IDC2009, unfortunately we were only able to finish a concept version. This concept version was available at the NUI Group booth.

NUI Group press release:

“We are proud to announce the release of the first edition of the NUI Group Community Book – Multi-Touch Technologies. This book comprises state of the art articles from our Community Wiki, as well as several chapters written by leading experts in the field specifically for this publication. Detailing basic hardware technologies as well as the process of developing software suited for multi-touch systems, this book provides a technical introduction to the world of multi-touch.

This book aims to provide an introduction to the multi-touch world for all backgrounds of people, and also include sufficient information to serve as a general “handbook” for those acquainted with the field, including code examples, suppliers, and building methodology.

Multi-Touch Technologies is a unique publication in its domain in that it is released at no charge under the Creative Commons 3.0 Attribution Share-Alike license – all content found in this book is free to be re-distributed and modified under a similar license, with attribution.”

View the full press release.
Download your copy here: First_Edition_Community_Release.pdf

Comments and suggestions can be posted in the feedback topic @ NUI Group forums.

* update 15 July *
Mirror of the NUI Book:
English version
Chinese version (special thanks to Kelvin / mt2a for translating the book, feedback can be posted here).

Google Summer of Code 2009

Like last year, the NUI Group will be coaching students to work on open source multi-touch projects. This year, I will be helping out by mentoring a student who will add hand tracking to Community Core Vision (formally known as tBeta).

Project: Recognition, Tracking and Association of Hands, Fingers, and Blobs: A Community Core Upgrade
Student: Thiago de Freitas Oliveira Araujo
Mentor: Laurence Muller

Follow his progress on his blog and his code on nuicode or google code.

Hand/Fingers occlusion testcase

Matching a hand model (using Active Appearance Models)

More videos can be found here.

Watch it in HD on Youtube or Vimeo!

Changelog for v3:

• Fixed compatibility issue with Adobe AIR 1.5 (Fullscreen bug)
• This version should autodetect your screensize to support any screen resolution.
• Added a Google Maps object
• Added support for adding pictures on the fly (for example if you want send a picture from your cellphone with bluetooth, read the readme.txt for the instructions)
• Added a exit-button, reset view-button, canvaslock and displaylock buttons.
• Temporary removed DCIM support due to slowdowns

Want to try it out yourself?
Download it now: Multitouch Media Application Pro v3 (12186) - 2.25 MB

Please read the install instructions in readme.txt (and download the latest Adobe AIR 1.5.x).

note: If you want to try out the bluetooth feature, I recommend installing BlueSoleil to handle the pairing of the devices and file transfers.

It has been a while since my last blog post, so I will try to catch up a bit.

Earlier this year, Chris Moore invited me to join the Interactive Displays Conference 2009 (IDC) in San Jose, CA, USA. The IDC is an event for hardware manufacturers, developers, researchers and end user of interactive display technologies. The event was organized by pira-international and supported with great keynote speakers: Jeff Han from Perceptive Pixels and Andy Wilson & Steven Bathiche from Microsoft Research.

The NUI Group was also present with a booth to demonstrate some of the current activities from the community. Key members (Seth Sandler, Chris Moore, Alex Popovich, Jimmy Hertz and Thomas Hansen (Author of PyMT) ) from the NUI Group community and NUI INC. where present to demonstrate their hardware and software achievements.

Jimmy Hertz presented his amazing and huge H2O AquaTouch Water Screen at the booth. Alex Popovich demonstrated his multi-camera solution based on custom drivers created for the PS3.

Jimmy setting up his touch screen

The NUI Group booth (with free NUI Group T-shirts!)

Alex’s multicamera solution with 3 PS3 cameras

A nice summary of the conference can found on the NUI Group blog. More photos can be found on the Flickr streams from Joan Woodbrey and Thomas Hansen

Seth, Justin and me heading to the car.

Photograph credits: Thomas Hansen

I would like to thank Chris and the other present NUI Group members for this amazing event, I really enjoyed my stay in San Jose and San Francisco.

Photos and videos

In my previous post on Interactive Networks, I gave a brief explanation of the concept. My colleague Rudolf Strijkers (Project lead) created a page with pictures and videos from the demo we presented. This page also includes a video of Rudolf explaining the Interactive Network concept to Gordon Cook. Only the video with Gordon Cook is in English, but I guess that most of the videos are self explanatory. The videos and photos be found here: Supercomputing 2008 media

COOK Report

After Gordon Cook was given a brief introduction to the Interactive Networks concept, he invited Rudolf Strijkers and Cees de laat for a more in-depth interview. The article (abstract) can be found here: ICT and E-Science as an Innovation Platform in The Netherlands “A National Research and Innovation NetworkWhat Can the US Learn from Dutch Experience?”

Posters

More posters from our booth can be found here: clickme!

Pictures of multitouch systems presented at SC 2008

RENCI Vis Group Multi-Touch

The guys from Renaissance Computing Institute were kind enough to show us their table. We could even take a peek under the black curtain that contained all the *magic*.

More photo and video content can be found on their blog.

EVL | Multi-Touch LCD Table Prototype

EVL showing a rain simulator on their LCD based multitouch table.

Checkout the video of the table here. More pictures of the setup can be found here.

Enthought

A stable, portable and responsive multitouch system using a python backend.

“Me painting like a pro, looks better than Picasso … right?”

MS Surface

This doesn’t really needs an explanation…

“Dear Santa, please send me a MS coffee table this year.”

[Show as slideshow]

12►

Because our old table (which we used for the multitouch performance experiments) was moved to the NEMO Science Center in Amsterdam, we had to develop a new multitouch system from scratch. Based on our experiences of building the previous multitouch table, we carefully choose our new hardware components (such as the camera and digital projector).

Supercomputing 2008

Supercomputing is an international conference for High Performance Computing, Networking, Storage and Analysis (SC08, November 15-21, 2008 Austin Convention Center). In collaboration with the Systems- and Networking Engineering Group of the University of Amsterdam we developed software and hardware for our project called Interactive Networks.

Our project consists out of several parts:

• The multitouch table; used as an input/interaction device (Rear illumination)
• Multiple (linux) computers using custom kernal software called streamline
• A controller that processes events from the multitouch table to the computer nodes using streamline (and vice versa).
• The Interactive Network Visualizer (the visualization and manipulation software on the MT table)

The project focuses on stream manipulation in a token based network. In Amsterdam we created a physical network of computer nodes (16+). Each of these computer nodes has the streamline module installed. Depending on the task of the node, a node can be the following:

• A producer (A node that is capable of delivering a video/content stream)
• A router (A node that is able to route packages)
• A consumer (A node that is capable of receiving and displaying the stream content)

In the current setup we have 4 producers (each with different video content), 8 routers and 4 consumers (Mac mini’s connected to HD screens with VLC installed to display UDP video streams).

In order to stream video content from the producer to a consumer node, users can simply switch to the ‘route planner’ mode and draw a line from node to node. When the user completes a path (stream), the result is submitted to the controller. The controller checks if the nodes are connected and instructs the nodes how the incoming packages should be handled. Normally it is difficult to distinguish different data streams from each other. However, in our system we added a ‘token’ (color) to each stream. This allows us to distinguish a stream on a particular node and transmit it to its destination. Our system has support for multicasting and streams containing cycles (unique!).

Because streams are tokenized we can also manipulate particular streams on the node itself. By double tapping a node, we can view the internals of this particular node. All streams that passes through this node can be viewed and modified. For this particular demo we added an option to add a sampler. The sampler allows the user to set a value of how many packages should be dropped.

By using standard Linux tools we are also able to measure the network throughput on a node, the load on a node, the used bandwidth between two nodes and the jitter on a connection. These values are visualized in our software.

Videocontent

For our demo we stream high definition videos from The Netherlands to the USA over an 4 GBit internet connection. We are using movies that were made in Blender, namely: Big Buck Bunny and the Elephants dream.

Live videofeed

On our dutch stand we have three live camera streams showing different projects, be sure to check those out: webcam overview

Other multitouch projects at SC08:

We certainly aren’t the only ones with a multitouch table at SC08, so far I’ve seen the following:

1. RENCI Vis Group Multi-Touch Blog
   Developing multitouch hardware and applications for research and experimentation.
2. EVL | Multi-Touch LCD Table Prototype (Tactile)
   A high resolution multitouch device created from a LCD panel Video!
3. Enthought (Scientific Computing Solutions)
   A fast and responsive multitouch solution using a python backend. They are located at the stand of Western Scientific
4. MS Surface (on the HPC stand)

Photos

Photos of our setup can be found after the break!

[Show as slideshow]

On the first day of the conference there will be a bootcamp on building your own multitouch surfaces.

At the bootcamp the ‘experts’ will share their knowledge and experiences on building multitouch surfaces. The following topics will be covered:

• Infrared Illumination
• Silicone & Projection surfaces
• Cameras, Optics, Filters & Projectors
• Software
• Hardware Integration
• Community & Network

I will be at one of the stands presenting the software part together with Ulrich von Zadow.

Hope to see you soon,
- Laurence

* Update *
We now have a website running with the bootcamp information.
- Project page: http://ifgi.uni-muenster.de/multi-touch-bootcamp
- Some photos of the conference: click me!

* Update 2 * (22/03/2009)
- IEEE tabletop bootcamp page update.
- Multi-Touch Surfaces: A Technical Guide (mirror)

1. Master’s thesis:
Multi-touch displays: design, applications and performance evaluation (3322)
Mirror: SCS – Master of Science theses
(1.4 mb)

2. Final presentation:
multitouch_presentation.pdf (3355)
(26.6 mb, includes embedded wmv videos)

3. Multitouch video:
multitouch-videomix1.wmv (2195)
(76.3 mb, high quality wmv)

*update 17-09-2008*
4. Multitouch experiment videos:
10 multitouch experiment videos

*update 20-10-2009 (mirrored files)*
4. Multitouch experiment videos:
10 multitouch experiment videos

4. Experiment videos:
Multitouch experiment videos (youtube playlist)

p.s. Sorry for the ending it wasn’t me!