• August 2010
• July 2010
• June 2010
• May 2010
• April 2010
• March 2010
• Complete archive

I just had the opportunity to take a video of my multitouch table with my software in action. Both hardware and software were built for my bachelor’s thesis which I handed in in march. The software that you see at the end is written in Python with PyMT, using the VTK library.

Medical Multitouch from Christopher Denter on Vimeo.

Reading through a planet? Click here!

For more information, see the video description. PS: Although it supports all platforms, it currently runs on ubuntu. :-)

Let me know what you think!

Many things happened in the last few weeks. I just want to quickly outline them in case you’ve been wondering what I’ve been doing.

PyMT Spelling

Starting with PyMT 0.5 (to be released in August), we added support for spelling correction and word suggestions. This is based on my GSoC work. The code has been polished and integrated into the master branch, which will soon lead to the 0.5 release. I’m also currently working on a text input widget that indicates incorrectly spelled words as you type (just as OpenOffice would). This much is working. In a next step, I plan to add a feature that lets you select from a list of suggestions for the word that you just tapped.

WipeToType

One of the tasks of my GSoC proposal is the implementation of a Swype-like keyboard. What this means is that you just wipe over the keys that make up the word you want to type and it automatically determines which word you intended to enter. It is clearly far beyond the scope of a single, multitouch-oriented GSoC proposal to implement something as clever as a Swype clone (especially since this also requires A LOT of backend code for the intelligence). However, something remotely similar and usable should be doable and is what I’m looking for. A while back I started something like this and quickly sketched a modified version of the virtual keyboard.

This still needs much more love, but keeping in mind that I did this in a really short amount of time I think I can say that we’re getting somewhere.

FITG in Lille

Thomas, Mathieu and I have had the chance to meet in Lille at the FITG conference and present PyMT in a talk and several workshops. This was a great opportunity and in fact, it was the biggest real-life meeting of core developers and users so far.

The conference itself was a great success, both for the organizers and us. We had many people come to us and ask questions concerning PyMT and Movid. After our talk (which I think was well-received) we decided to give an additional workshop so that people interested could play with PyMT and get help from us. The room was pretty crowded and people were standing. The workshop presented a basic PyMT overview and first steps in a ‘hello world’ fashion (At least I think that’s what Mathieu was talking about. He spoke french and Thomas and I were answering questions or translating things in English). In the evening we gathered all the people that were still at the conference and went to a nice little restaurant to chat.

The next day we gave two more workshops. The idea to do the first one came up while we had breakfast. We decided to implement a simple version of the game at linerider.com with PyMT. When we arrived an hour later, we just picked a python 2D physics library that was easy to install and started live and from scratch, without any actual code having been written (or even thought about) beforehand. Luckily it all turned out well. After almost exactly one hour (in which Mathieu helped people in the audience, Thomas pointed to and explaining stuff at the projection and I coded and talked) we had finished what we were looking for in just 60 lines of unoptimized python code. The last workshop was about advanced OpenGL. Mathieu presented some of his insights that he had gathered while optimizing PyMT’s performance (great advances have been done here, by the way).

I stayed four days in total and it was absolutely worth it. Lille is a wonderful city and the conference was fantastic. The venue itself was just mind-blowing to begin with. We had a lot of fun together and obviously worked on PyMT as well. It’s even more fun if we’re in the same room! Sincere thanks to everyone involved in making these days as awesome as they were!

Reworked TextArea

For our talk in Lille, we used a very nice presentation tool (PreseMT) which is, obviously, written with PyMT. While using it for my own bachelor’s colloquium (I’m officially a Bachelor of Science now, by the way) I noticed that entering text suffered from severe limitations of the text input widget. Given that I had no multitouch-capable device around to enter text, I did it all with my hardware keyboard. I added to PyMT’s TextArea widget the ability to resize automatically depending on the text that was entered (which is what you want in PreseMT). Furthermore, the widget now properly reacts to several special keys like the arrow keys, home, end, del, pgup and pgdown.

Portable PyMT

It is no secret that installing PyMT on OSX is a major pain. This is not our fault, though. The problem simply is that installing almost anything in non-app format involves a non-trivial compilation process using MacPorts and the like. Unfortunately, one of our dependencies (gstreamer) is not easily installed this way.

Since we really don’t want our users to go through all of this, we decided to distribute portable versions of PyMT for OSX, Linux and Windows. I did the OSX version and hope to be able to finish it soon so that it can be reviewed. With it, you just download a zip file, unzip it and go. It contains everything that is needed to run PyMT.

In the course of this, I also fixed the compilation of our OpenGL-dependant cython modules for OSX.

Conclusion

Hopefully you will see a wonderful PyMT release next month. We’ve added many new features, improvements and fixed a lot of bugs. Some of my GSoC work will also go into it. In terms of GSoC, I will finish the aforementioned spelling-aware text input widget. I also intend to improve the quality of the results of the WipeToType keyboard and implement the things left on my GSoC proposal.

The NUIGroup Google Summer of Code students (I was lucky enough to become one of them for PyMT this year) are asked to summarize their weekly activities in blog format. Given that the first week has passed I figured I should just quickly outline what I have been working on up to now.

My proposal aims at developing more advanced text input methods for PyMT.

Work on PyMT

Some of the ideas I will realize draw heavily upon spelling correction and suggestion. It is therefore necessary that PyMT can interact with a spelling backend. Given that PyMT should be kept modular, I first implemented an abstract new core provider for spelling suggestions to become independent of a specific library. I then realized two concrete implementations of this provider:

• An enchant spelling backend. This uses the enchant spelling library which can itself be used with different kinds of dictionaries.
• A spelling backend based on OSX’s AppKit spell checker.

After the foundation was laid out I adapted a virtual keyboard with spelling support that Mathieu once developed to the new API and added it to the code base. All of this is not yet finished and needs some more love before I can merge it back into the master branch. You can check the branch I’m currently working on here.

Work on Movid

While spellchecking is important for some of my upcoming widgets, some other text input approaches make use of additional information provided by the tracking application. For example, one idea I had was to split the keyboard in half and dedicate one half to each hand. The halves would then automatically orient themselves following the respective hand’s position and orientation. Theoretically, further information such as properties of the user’s hands (length of fingers, etc.) could be taken into account to lay out the keyboards. For this I obviously need some kind of hand and fingertip tracking. Luckily I implemented that for Movid already:

However, since Movid is still not ready for end users due to a missing calibration utility and a proper (generic!) blob tracker (which means I can’t use it yet either), I continued my work on both of those. Again, both of which are not finished, but I can see the light at the end of the tunnel (or rather, the light below my fingers):

I hope that we can finish all of this and push out a first version of Movid for end users soon. And obviously, I want to test my text input widgets on my multitouch table and not in the mouse simulator.

This concludes my work for week one. If you have any questions or are interested in PyMT or Movid, feel free to join our IRC channel at #pymt and #movid on irc.freenode.net.

From 10th to 12th of June (next month!) there will be an awesome conference in Lille, France for those interested in Multitouch and other HCI topics such as gestural interaction. There is no entrance fee. The conference consists of three parts:

• Workshops, which are basically talks with discussion afterwards
• Showrooms, where people can exhibit their stuff (e.g. multitouch tables)
• BarCamp, a more community-driven place to gather, discuss and share.

We (the PyMT team) have submitted a paper and hope that we can give a talk about our nifty framework. Make sure to check out their website and register (Registration is free. It’s just for the organization to get an idea about the number of participants)!

I will be there to meet people, talk, get inspired and, of course, hack. I’ve recently been in Lille for a similar reason and I can assure you that it’s a nice city. If you’re interested in the topics, you should definitely consider attending!

Hi everyone, I am glad to announce the birth of the Movid project: movid.org

Movid is an acronym; it stands for ‘Modular Open Vision Interaction Daemon’. It’s a cross-platform and Open Source vision tracker, designed to be as modular as possible. Although the project is pretty young, it already features more than 20 modules, including blob and fiducial trackers as well as TUIO output. Movid is coded in C++, and use WOscLIB, cJSON, libevent, libfidtrack, jpeg-8 and XgetOpt.

Movid has several key characteristics:

• Cross-platform: It works under Windows, Linux and MacOSX.
• Daemon: You can run the program without a GUI and control it from another computer over the network.
• Threading: Each module can be run inside a thread. This means that you can finally fully utilize your multi-core processor!
• Remote API: The daemon can be controlled with a JSON API. This also means that you can write your own GUI, e.g. in Flash, and the daemon can be controlled from any application that can make http requests!
• Full HTML5 embedded administration: By default, the daemon acts as a HTTP server. You can control and modify the tracking pipeline in real-time and adjust many parameters.
• Image streaming: Most modules process images. For your application or GUI, you can get the output image via a stream. So your applications can show any image from the piepline or use it for advanced features
• Flexible pipeline: Unlike other applications, Movid allows you to fine-tune your image processing pipeline if you are an expert. You can create new pipelines, add modules/filters and change their parameters in real time.

However, Movid is not ready for users yet, since we are missing a few modules, like calibration. Right now, we are searching developers to support us with the further development.

More info:

• Licence: QPL (Open Source)
• Website: movid.org
• Documentation: movid.org/Documentation/Index
• How to contribute: movid.org/Documentation/HowToContribute
• Source Code: github.com/tito/Movid
• Developers ML: groups.google.com/group/movid-dev
• Movid on techsparked.com: techsparked.com/project/movid
• Vimeo videos: Vimeo group
• Fiducial tracking: vimeo.com/11047041
• Introduction to Movid: vimeo.com/11056184
• (If the videos are not working yet, you can check these mirrors: http://txzone.net/files/projects/movid/screencast-fiducial.ogv http://the-space-station.com/~dennda/gallery/mt/movid.m4v)

The core team currently consists of:

• Christopher Denter
• Mathieu Virbel
• Seth Sandlers
• Thomas Hansen

So, I’ve just handed in my bachelor’s thesis and got some time to blog again. The BSc thesis and the things I’ve been working on the last couple of months are for an extra blog post, though.

Right now I just want to bring a new website to your attention. In case you’re as much interested in emerging technologies such as multitouch as I am, you might definitely want to check out techsparked.com

See you there!

The awesome PyMT library has just been released in version 0.4.

This is a major release that brings a ton of cool new stuff, including a new animation framework, speed & stability improvements and much more. Take a look at the release notes to see what’s new in this release.

I’m using PyMT for my thesis (see picture above) and I love it. Make sure to check the new website, too! (There’s also a new demo video in the works. I will update this posting as soon as it’s available.

I just want to share the following video. Seriously, how awesome is this? (Click this posting’s title if you’re reading via a planet to see the video.)

That thing runs Gentoo.

Source.

For those of you who don’t know it, if something provides Multi-Touch input methods, it means that you (and potentially an almost arbitrary number of other people) can interact with the same device using as many of your fingers as you like.

This technique is relatively new to most of us and I have been blown away when I first saw a video of someone interacting with a so-called Multi-Touch table:

(If you’re reading this posting via a planet or feed reader, please click this posting’s title to see the videos on my blog directly.)

In case you like the python programming language, you might be as excited as I was to know that there’s actually a library that allows you to write multi-touch software yourself. This library is PyMT. It’s based on top of OpenGL and allows you to deal with multi-touch input events in a nicely abstracted way. PyMT is cross-platform, open-source and actively developed. It comes with many examples, a mouse simulator (in case you don’t have such a table) and (in the development branch) support for the new touchpads found in recent macbooks as well as other types of hardware (HP touchsmart, etc.). Here’s an old demo video that shows what PyMT is capable of already:

I was so impressed by what is possible that I started diving into the matter quite some time ago. I’m even building my own table at the moment. The thesis I’m currently working on also relies on PyMT. If you got an appetite, feel free to join us in #pymt on irc.freenode.net or the mailing lists.

In order to show you how easy it can be, here’s a quick demo I just wrote.

If you are interested in building your own hardware (yes, you can), let me suggest you take a look at the excellent NUI community. They have software, forums and even a book available for free for you to learn and explore.

During 2008′s Google Summer of Code I introduced a new storage abstraction layer to the MoinMoin wiki engine. This allows you to run moin on a variety of backends (filesystem, mercurial, etc.).

This year (2009) I participated again. My application contained three major areas of work:

• Reintroducing ACLs for the storage branch.
• Adding fairly advanced ‘routing’ configuration capabilities for your storage backend(s).
• Adding a SQLAlchemy backend which, in theory, should support a variety of RDBMS.

The first two objectives were finished quite well. Two different pieces of middleware were introduced for both, the ACLs and the routing. You can now use several different backends in a simple or optionally fairly complex way. You could just use one single filesystem backend or potentially hundreds of different backends, each with different ACLs applied, and mount each one into its own namespace (you may be familiar with this concept from UNIX, where you can mount discs and such into arbitrary places of the filesystem tree).

In addition to that, ACLs have been refactored. ‘revert’ and ‘delete’ were removed (obviously you will still be able to perform the corresponding actions from the UI), ‘create’ and ‘destroy’ were added.

As for the SQLAlchemy backend, we do have a somewhat working version. Unfortunately it still suffers from severe performance problems. Originally I wanted to fix that after SoC, but real-life (bachelor’s thesis, etc.) caught me, so I will have to postpone that. If you have some SQLAlchemy experience and want to help out here (or with something else), you are very welcome to join us (#moin-dev on irc.freenode.net).

For an overview of what else has been done during GSoC 2009 on the storage side of things, take a look at the following resources:

• http://moinmo.in/Storage2009
• http://hg.moinmo.in/moin/2.0-storage/

Please keep in mind that this is still fairly alpha. Especially the UI is for developers and geeks only and will be redone properly (with Jinja2) before the release (help needed here as well).

Thanks to the whole moin crew and especially my mentor Thomas Waldmann for the nice and fun collaboration!

(Oh and – hopefully – hello planet python!)