I came across the LumenLab database of monitors a few days ago, and my 17 Inch Monitor(Samsung 712N) was on the list of those that didn’t have FCC Issues, so I figured I would give it a go at taking it apart and mounting the camera behind it.  If it turns out to work well I might make a nice box for it.

Taking apart this monitor was amazing, and I _HIGHLY_ recommend it for anyone trying to find a small monitor to take apart for such a project.  It is amazing how high quality and easy to take apart it was built, its almost like they took us into consideration when they designed it!  Ill post a more details description with pictures later(once I take some:)).

I am going to follow the same tutorial format I used last time, where I give you the code and explain it line by line.  In this tutorial we will also take a new approach at getting touch events, through a new type of callback called a Decorator(read more about them here).  They are similar to Java’s Annotations, and are purely a way of representing this(from the first tutorial):

class Observer(object):
    def __init__(self, subject):
        subject.push_handlers(self)

class touch_up(Observer):
    def TOUCH_UP(self,blobID, xpos, ypos):
        #Do something here

class touch_down(Observer):
    def TOUCH_DOWN(self,blobID):        
        #Do something here

class touch_move(Observer):    
    def TOUCH_MOVE(self,blobID):        
        #Do something here

t = touchpy()
tu = touch_up(t)
td = touch_down(t)
tm = touch_move(t)

With this:

@t.event
def TOUCH_DOWN(blobID):    
    #Do Something

@t.event
def TOUCH_MOVE(blobID):    
    #Do Something

@t.event
def TOUCH_UP(blobID):    
    #Do Something

Not only is it _much_ easier to write, but its a lot easier to read, and actually makes sense. So, moving on to the code. I have not commented to the code, because I will be going over it line by line here, and I figured comments would make it longer then it has to be. I tried to make this as short as possible while still being readable, so its very global oriented. I would assume all tutorials from here on out will follow better practice, as they will do more complicated things(The next tutorial will either be a Picture app, or a simple button GUI, not sure yet, but I will get to both eventually). So, the code:

import sys
import math

import pygame
from pygame.locals import *

from touchpy import touch
from touchpy import utils

def make_rectlist(pos, size):    
    return (pos, (pos[0] + size, pos[1]), (pos[0] + size, pos[1] + size), (pos[0], pos[1] + size))

def get_distance(x1, y1, x2, y2):    
    return math.sqrt((y2 - y1)**2 + (x2 - x1)**2)

sz = utils.get_sz()

pygame.init()screen = pygame.display.set_mode(sz, pygame.FULLSCREEN | pygame.NOFRAME)

pos = [(x/2) - 50 for x in sz]size = 100bList = []

t = touch.touchpy()

@t.eventdef TOUCH_DOWN(blobID):    
    global bList
    bList.append(t.blobs[blobID])

@t.eventdef TOUCH_MOVE(blobID):    
    global bList, sz, size
    if len(bList) == 1:
        pos[0] += t.blobs[blobID].xmot*sz[0]
        pos[1] += t.blobs[blobID].ymot*sz[1]    
    elif len(bList) == 2:
        oDist = get_distance(bList[0].oxpos*sz[0], bList[1].oxpos*sz[0], bList[0].oypos*sz[1], bList[1].oypos*sz[1])        cDist = get_distance(bList[0].xpos*sz[0], bList[1].xpos*sz[0], bList[0].ypos*sz[1], bList[1].ypos*sz[1])

        z = round(oDist / cDist, 1)
        if z >= .5:
            size /= z

@t.event
def TOUCH_UP(blobID, xpos, ypos):    
    global bList
    bList.remove(t.blobs[blobID])

while 1:
    screen.fill((0, 0, 0))
    pygame.draw.aalines(screen, (0, 255, 0), True, make_rectlist(pos, size))
    for event in pygame.event.get():
        if event.type == QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE):
            sys.exit()
    t.update()
    pygame.display.flip()

We will be skipping all the imports, because they should make sense. If they don’t I would recommend going back and reading tutorial 3 again. There is one new one though, that deserves at least a small mention.

from touchpy import utils

Since the last tutorial some changes to TouchPy have been made. Nothing that drastically changes how it operates, just some new features that make working with it a lot easier. A __init__.py file was added, so it can now be imported as a package, and a utils.py file was added. All this file does is allow you to get screen dimensions, but it does work across all platforms through a single function, which is really nice.

def make_rectlist(pos, size):
    return (pos, (pos[0] + size, pos[1]), (pos[0] + size, pos[1] + size), (pos[0], pos[1] + size))

def get_distance(x1, y1, x2, y2):    
    return math.sqrt((y2 - y1)**2 + (x2 - x1)**2)

Next we have two functions, make_rectlist() and get_distance(). make_rectlist() simply takes the position(bottom left corner) and size of a rectangle, and returns the position of each vertex(in pixels), in a four element tuple. get_distance() uses the distance formula:

To calculate the distance in pixels between two points(in pixels).

sz = utils.get_sz()

This line uses that utils file we talked about earlier to get the screen size in pixels. It would be a good idea to remember this function, as it works across Linux, Mac OS, and Windows, and is very helpful for almost any application with graphics involved. get_sz() returns the size of the screen in pixels as a two element tuple, so on my system it returns (1280, 1024).

I believe I have adequately explained the next two lines, but if you do not understand them I recommend going back and reading tutorial 3.

pos = [(x/2) - 50 for x in sz]
size = 100

All this does is center the box on the screen. You do not have to worry about understanding this line, but if you do thats great! All its doing is taking each screen dimension, diving by two, and subtracting 50(half the size of the box). The same thing could be accomplished with:

pos = [sz[0] / 2 - 50, sz[1] / 2 - 50]
size = 100

Both pos and size are global variable that are constantly updated. pos holds the position of the box(bottom left corner), and size holds the length of one side(its a square). They are both mutable, because during the callbacks we update these values, then pass them through pygame.draw.lines to draw our square.

bList = []

This just defines another global, bList, which we use to hold all of the blobs that are currently alive, or have actual positions on the screen. You will see why this is useful when we get to the TOUCH_MOVE callback.

The next line instantiates the touchy objects, which you should understand pretty well by now, and if you don’t, I would recommend reading tutorials 1 and 2. Finally, we get the exciting part of the program!

Starting with the TOUCH_UP Callback:

@t.event
def TOUCH_DOWN(blobID):
    global bList
    bList.append(t.blobs[blobID])

This example uses a new callback-triggereing mechanism that I have not mentioned before. They are called decorators. I have already mentioned them, but I will again suggest you read this for more information.

Moving on to the actual contents of this we see two lines.  The first just tells Python to include the global list bList into the scope of this callback, so we can access its elements.  The next appends the blob that was touched down(t.blobs[blobID]) to bList.

The TOUCH_MOVE callback is a bit more complicated, so we will skip over that for now and go over the TOUCH_UP callback.

@t.event
def TOUCH_UP(blobID, xpos, ypos):    
    global bList    bList.remove(t.blobs[blobID])

This does the opposite of TOUCH_DOWN. It takes the blob that caused the TOUCH_UP event, and removes it from the list. We do this because we are trying to keep bList current with the blobs that are actually on the screen, and thus we must remove the blobs that are no longer on the screen.

@t.event
def TOUCH_MOVE(blobID):    
    global bList, sz, size
    if len(bList) == 1:
        pos[0] += t.blobs[blobID].xmot*sz[0]
        pos[1] += t.blobs[blobID].ymot*sz[1]    
        if len(bList) == 2:
            oDist = get_distance(bList[0].oxpos*sz[0], bList[1].oxpos*sz[0], bList[0].oypos*sz[1], bList[1].oypos*sz[1])
            cDist = get_distance(bList[0].xpos*sz[0], bList[1].xpos*sz[0], bList[0].ypos*sz[1], bList[1].ypos*sz[1])

            z = round(oDist / cDist, 1)        
            if z >= .5:
                size /= z

In this callback we decide whether the user wants to resize, or move the box. If there is one blob then it is assumed that they want to move the box, which is done by adding the relative movement of the blob to the position of the box.  If there are two fingers on the table then it is assumed that they would like to resize the box.

        oDist = get_distance(bList[0].oxpos*sz[0], bList[1].oxpos*sz[0], bList[0].oypos*sz[1], bList[1].oypos*sz[1])

In this line we get the distance between the old position of the blob(oxpos, oypos) in pixels using the distance formula. In the next line we do the same with the current position. Next we get the ratio of change between the two, and apply this to the zoom. This achieves the effect of zooming in. This is not the best way to do it, as you will notice it is a bit jerky, and will jump around at times. In a future tutorial I will present some better ways of zooming.

while 1:
    screen.fill((0, 0, 0))
    pygame.draw.aalines(screen, (0, 255, 0), True, make_rectlist(pos, size))    
    for event in pygame.event.get():        
        if event.type == QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE):
    sys.exit()
    t.update()
    pygame.display.flip()

Next we have the main program loop. This is pretty simple. Clear the display, draw the box, see if the user wants to quit(hit the escape key or get QUIT event from OS), updates touchpy, then flips PyGame’s display.

That concludes this tutorial!  As always, if you have any suggestions or ideas for a new tutorial I am happyto hear them!  I don’t really know where to go from here with the tutorials, I think I will start with something useful, or maybe kinetic scrolling, who knows…  I would love to hear from you and see what you have to think!

Recommended resources for further reading:

• An explanation of Python decorators

It does support a ZUI, but it is not a “full ZUI”.  It does have simulation limits, so if an object happens to leave this limit it will freeze(as seen in video below).  It also does not implement the Gear Joint, but all the other joints are supported.

Its still in early development, so it has its share of bugs.  The biggest has to do with triangles.  When you choose to make an arbitrary polygon, it works fine with any number of vertices between 4 and 8, but once you try 3 weird things happen.  Half of the time it will work, and the other half it won’t.  Due to the way PyBox2D was coded, I can’t catch this error either(or any Box2D error, for that matter), so the program will unceremoniously exit.

Code can be had from the downloads page, and here is a video!

Get started by firing up your favorite editor and making a new Python file.  I named mine PyTracer.py, but you can name it anything you want.

So, lets get started coding!

In this program I am going to take a new approach to doing tutorials.  I am going to give you the whole program, then explain it line by line, so you can easily skip over parts you understand, or read through the whole thing.

So, lets get started!

import sys

import pygame
from touch import touchpy

screen_dimensions = (1280, 1024)

t = touchpy()

pygame.init()
screen = pygame.display.set_mode(screen_dimensions, pygame.FULLSCREEN | pygame.NOFRAME)

while 1:
    screen.fill((0, 0, 0))
    t.update()

    for event in pygame.event.get():
        if event.type == pygame.QUIT or event.type == pygame.KEYDOWN:
            sys.exit()

    for blobid in t.blobs:
        x = int(round(t.blobs[blobid].xpos*screen_dimensions[0]))
        y = int(round(t.blobs[blobid].ypos*screen_dimensions[1]))

        if blobid % 2 == 0:
            pygame.draw.circle(screen, (232, 4, 40), (x, y), 50)

        else:
            pygame.draw.circle(screen, (40, 232, 20), (x, y), 50)

    pygame.display.flip()

So, now we can go through this line by line.  Before I start explaining that, notice a few things:

• This program does not use any callbacks, unlike previous tutorials
• To get touch events. we iterate the t.blobs dictionary
• The main loop is most of the program, where it used to just be t.update()

Each of these will be explained in more detail as the tutorial goes on.

import sys

import pygame
from touch import touchpy

Here we import all the necessary libraries.  This is pretty self explanatory, but I will explain it anyway.  We import sys purely for sys.exit(), so we can exit whenever the user hits a key.  PyGame is the graphics library we use to draw the circles, so naturally we should import it.  If you have not played around with PyGame, you are missing out.  Check it out here, its an awesome graphics library.  Next is the line you should be used to seeing by now, importing the TouchPy library.  In case you have not read PEP 008, you should always differentiate between built in libraries, third party installed libraries, and local file includes by spacing them with newlines.  I highly recommend you read PEP 008 for tips on style in Python coding.  It makes your code a lot easier to read, and 99% of Python coders follow this standard.  It can be found here.

screen_dimensions = (1280, 1024)

You should also be familiar with this line. It is used to convert TouchPy coordinates into pixel coordinates. Of course, set this to your own screen resolution.

t = touchpy()

This line imports the TouchPy framework, and opens the network socket. TouchPy should always be the first thing you initialize in your program, because sometime it can take a long time to initialize. This way, it waits until TouchPy is ready to start the GUI. If you put this after the PyGame initialization it would open a window before it was ready, and then “stack up” touch events, then release them all at once when TouchPy was ready.

pygame.init()
screen = pygame.display.set_mode(screen_dimensions, pygame.FULLSCREEN | pygame.NOFRAME)

If you have had any experience with PyGame, this line should be very familiar, otherwise, Ill explain it. The first line initializes PyGame by going through each imported module and initializing it. The second line makes a screen for us to blit(copy images) onto. The first argument is the size(in pixels) of the window you want. We pass the screen size in, because we intend to make this program full screen. Then next arguments are graphics options, you can pass nothing in and it will run fine, but we want it to be full screen and have no frame. This is just fancy for saying override everything(panels, other windows), and hog mouse/keyboard input(don’t allow to lose focus until program exits).

while 1:
    screen.fill((0, 0, 0))
    t.update()

    for event in pygame.event.get():
        if event.type == pygame.QUIT or event.type == pygame.KEYDOWN:
            sys.exit()

    for blobid in t.blobs:
        x = int(round(t.blobs[blobid].xpos*screen_dimensions[0]))
        y = int(round(t.blobs[blobid].ypos*screen_dimensions[1]))

        if blobid % 2 == 0:
            pygame.draw.circle(screen, (232, 4, 40), (x, y), 50)

        else:
            pygame.draw.circle(screen, (40, 232, 20), (x, y), 50)

    pygame.display.flip()

This is our event loop.  All the action happens here, so, lets go through it.

    screen.fill((0, 0, 0))

This line clears the screen to black. If we did not have this line, it would act more like a paint program. Comment it out and try it. If you have never dealt with computer animation this may seem strange, but it makes sense once you get it(doesn’t everything:D). If this is new to you, I recommend you read this for a really quick intro to PyGame/Computer animation.

t.update()

This line should be very familiar by now, but it deserves an explanation all the same. This line calls the “update” method of theTtouchPy object. In this method it clears the event queue, then checks for new TUIO events through server.recv(0). If you were to comment out this line nothing would happen, because TouchPy would never check for new TUIO events.

    for event in pygame.event.get():
        if event.type == pygame.QUIT or event.type == pygame.KEYDOWN:
            sys.exit()

This is the code that lets you quit the program.  It will call sys.exit() on two conditions:

1.  It was told to quit by the OS(kill system call, close button clicked, system shutdown imminent, etc)

2.  A key was pressed on the keyboard

for blobid in t.blobs:
        x = int(round(t.blobs[blobid].xpos*screen_dimensions[0]))
        y = int(round(t.blobs[blobid].ypos*screen_dimensions[1]))

        if blobid % 2 == 0:
            pygame.draw.circle(screen, (232, 4, 40), (x, y), 50)

        else:
            pygame.draw.circle(screen, (40, 232, 20), (x, y), 50)

This is where the real magic happens. Here it gets the coordinates of all the touches, and draws circles there. The for loop is iterating through the list blobs, which is an attribute of the TouchPy object, t.  t. blobs is a dictionary of blobIDs and Tuio2DCursor Objects.  We iterate through the list of blobIDs, then use that as the index to get the actual Tuio2DCursor Object.  Then next two lines get the x and y position in coordinates.  If you don’t understand this, you should go back and (re)read part two.

        if blobid % 2 == 0:
            pygame.draw.circle(screen, (232, 4, 40), (x, y), 50)

        else:
            pygame.draw.circle(screen, (40, 232, 20), (x, y), 50)

This is where the circles get painted. All the if statement is for is just to add some pizazz to the program. It just colors every other blob red or green. You could replace the whole if statement with one of the circle paint statements and it would still work fine. Speaking of circle paint statements, this is a PyGame function for drawing a circle. It does not need an image to be blitted, you just pass it the screen you want it on, color, position, and radius.

pygame.display.flip()

In computer animation there are really two images of the screen. The one that is being shown, and the one that you are modifying. Every time you want something new to show up you flip them, so you show the one you modified, then modify the other one. If this doesn’t make sense you should read the PyGame into here.

That concludes this tutorial. I think the rest of the tutorials will follow this form, except maybe the first few after Python-Lux comes out. I appreciate all feedback, and would love to hear how well this tutorial went for you. Also, if you have any ideas for a tutorial, let me know:) I am going to try and do about one every two weeks, and see how that goes. Thanks for reading!

Other interesting Python stuff you may want to read:

• An Overview of how Computers handle Graphics
• A quick intro to Computer Animation and PyGame
• Style guide for Python Code

In the last tutorial we made a really useless example, where every time each TUIO event happened, it would print out “Something left the table”, “Something moved on the table”, or “Something was placed on the table”.  We are going to further extend this program to print out where it happened.

So, get started by firing up your editor and opening hellomt.py.  If you are particularly fond of your first program, you can copy it and name it hellomt2.py, or whatever you want for that matter.  No explanation of this program is needed, because you wrote it:)

If you noticed, common between all three callbacks is an argument that gets passed call blobID.  blobID itself in an integer, which contains the blobID of the blob the callback is referring too.  On every print line you wrote in the last tutorial, add this to the end:

+ str(blobID)

Now cd into the directory where the program lies, and run the program:

python ./hellomt.py

Now when you touch the surface it should print “Something was placed on the surface 1″.  And every time you touch that number should increase.  The blobID is the index of a list called blobs.  You access blobs through the Observer.  In this program the Observer is instantiated as ‘t’, so you would access it as t.blobs.  t.blobs is a list of TUIO2DCursor Objects.  If you were to print t.blobs, each entry would look something like this:

<touch.Tuio2DCursor object at 0x823f36c>

If we poke around TouchPy a bit(or just pass t.blobs[blobID] through the dir() function, we can figure out that it has the following attributes:

['Height', 'Width', '__class__', '__delattr__', '__dict__', '__doc__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__str__', '__weakref__', '_event_stack', '_get_handlers', '_raise_dispatch_exception', 'blobID', 'dispatch_event', 'event', 'mot_accel', 'move', 'oxpos', 'oypos', 'pop_handlers', 'push_handlers', 'register_event_type', 'remove_handler', 'remove_handlers', 'set_handler', 'set_handlers', 'xmot', 'xpos', 'ymot', 'ypos']

The only ones we really care about right now are xpos and ypos.  In other tutorials we will get to more of them, such as Height, Width, xmot, ymot, and probably others as well.  So, how do we get the x and y position of a blob?  Like this:

x = t.blobs[blobID].xpos
y = t.blobs[blobID].ypos

If you understand this line then skip this paragraph.  Otherwise, if you are still unclear(like I always was when I started Python), read on.  This line accesses the List “blobs”(which is a list of TUIO2DCursor Objects, or pretty much its a list of blobs), that is inside the observer(named ‘t’).  Because its a list, it has an index, and the index of the blob we want is blobID.  That returns a TUIO2DCursor Object, which we take the xpos attribute of.

So, to print the x and y position of each blob, lets do this:

Replace your print line in touch_up with:

x = t.blobs[blobID].xpos
y = t.blobs[blobID].ypos
print ‘Touch Up at ‘ + str(x) + ‘ , ‘ + str(y)

Replace the print line in touch_move with:

x = t.blobs[blobID].xpos
y = t.blobs[blobID].ypos
print ‘Touch Up at ‘ + str(x) + ‘ , ‘ + str(y)

You should be able to figure out how to do the last one(touch_down).

When you run this program, each line should look like this, substituting Touch Up for the right event:

Touch Up at 0.478175550699 , 0.86176776886

If you look at those coordinates, evidently they are not pixel locations.  To get decimal coordinates, multiply each x coordinate by the width of the screen, and each y coordinate by the height of the screen.  Because I am anticipating people reading this guide will be running many different Operating Systems, I will not show any specific way to get the screen resolution, and have people hard code their screen resolution into the program.  Make a global constant-tuple at the top of your program(anywhere before the callbacks is fine) with your screen dimensions.  Mine looks like this:

screen_dimensions = (1280, 800)

Then in your callbacks on the lines that you calculate the X value, add this to the end:

*screen_dimensions[0]

Which is simply, multiply by the screens X dimensions.  Do the same for the Y calculations, except multiply by the Height of the screen.  Run your program, and observe the output.

Each line should look like this, substituting the correct event:

Touch Up at 832.000045776 , 49.9999940395

Now you have More accurate pixel coordinates, but you can’t really put a dot half-way through a Pixel.  Solve this by int-rounding each calculation.  int-rounding is the name I made up for the process of rounding to the nearest whole floating number, then making this an integer.  You do this by passing your calculation through int(round()).  The X calculation would look like this:

x = int(round(t.blobs[blobID].xpos*screen_dimensions[0]))

Do this to all of the calculations, both x and y.  Now running your program should yield results similar to these, substituting the correct event:

Touch Up at 922 , 492

Congratulations!  You can now get X and Y position of events! In the next tutorial we will write a small program using Clutter to draw circles over all the blobs.

These tutorials assume basic knowledge of Python, and at times may use some obscure feature of the Standard Library.  If you have any questions regarding something you don’t understand, or anything else about Python Development and such, feel free to email me at xelapond @ gmail . com, or PM me on nuigroup(username xelapond).  I also usually hang around IRC, #nuigroup, username xelapond.  I am happy to assist you with any problems you are having, and I would love feedback on how well this tutorial goes.

NOTE:  A lot of this is going to change soon with the release of Python-Lux.  Lux is a multimedia framework tuned for Multi-Touch Multi-Model interactions.  Once it is released you will not need to use the TouchPy callbacks for 90% of apps.  They are still nice to know though, for any application you don’t intend on using Python-Lux for.

NOTE 2:  WordPress appears to have killed the indentation on the code snippets.  In your code, follow standard Python tabbing and you should be fine.

This guide assume you have the following:

• Working TUIO Source(TUIO Sim, Touchlib, tbeta)
• A working TouchPy installation.  Though there are many great TUIO parsers for Python out there, my favorite is TouchPy.  I think it is the most capable, and easiest to use in a client application.  It requires no knowledge of how TUIO works.
• Python 2.5.2(I Haven’t tested it with any other version, let me know if it works)

This guide was written from a GNU/Linux Standpoint, but most(if not all) if the code should work on Mac OS X or Windows.  I do not know if it is possible to install liblo(needed for TouchPy) on Windows, so if you managed to do it please let me know how:)

So, lets get started!

cd(or use a GUI if you like) into your TouchPy directory.  If you deleted it after you installed, no big deal, just check it out again.  If you do have one laying around, make sure it is svn revision 65 or later.  Copy(not move) the skeleton.py file to wherever you would like to keep your Multi-Touch programs.  I usually put programs I write as the result of a tutorial in ~/Programming/Practice.  But that is a matter of personal preference, it doesn’t matter where you put it.  Name it hellomt.py.

So, looking at this file, what do we see.

#! /usr/bin/python -u
”’
This is a Skeleton file.  It provides a
template to be used when writing a new
TouchPy application.
”’

from touch import *

class Observer(object):
def __init__(self, subject):
subject.push_handlers(self)

class touch_up(Observer):
def TOUCH_UP(self,blobID, xpos, ypos):
#Do something here

class touch_down(Observer):
def TOUCH_DOWN(self,blobID):
#Do something here

class touch_move(Observer):
def TOUCH_MOVE(self,blobID):
#Do something here

t = touchpy()
tu = touch_up(t)
td = touch_down(t)
tm = touch_move(t)

try:
while True:
t.update()

except (KeyboardInterrupt, SystemExit):
del t

Some of this should already make sense to you, but I am going to explain it line by line anyway.

from touch import *

Imports the entire TouchPy library into the local namespace.

class Observer(object):
def __init__(self, subject):
subject.push_handlers(self)

You can safely ignore this for now.  We will get to it in later tutorials.

class touch_up(Observer):
def TOUCH_UP(self,blobID, xpos, ypos):
#Do something here

This is the code that will run when a blob is “upped”, or removed from the surface.

class touch_down(Observer):
def TOUCH_DOWN(self,blobID):
#Do something here

This is the code when a blob is “downed”, or placed on the surface.

class touch_move(Observer):
def TOUCH_MOVE(self,blobID):
#Do something here

This is the code that is run when a blob is moved.

t = touchpy()
tu = touch_up(t)
td = touch_down(t)
tm = touch_move(t)

This code is there so that with one command(t.update()) you can dispatch any changes in blobs to the appropriate callbacks.  It will be explained in more detail in later parts of the tutorial.

try:
while True:
t.update()

except (KeyboardInterrupt, SystemExit):
del t

This code pretty much says, “While the program is running, keep tracking and reporting blob data.  Otherwise, delete everything and exit”.  There are many different ways to do this same chunk of code, and in later parts we will change this to a gobject.timeout, and many other scheduling techniques.

Now that you [hopefully] understand at least some of the TouchPy front end, lets get coding!

In the touch_up callback, delete the comment and add:

print ‘Something Left the Table!’

in the touch_move callback, delete the comment and add:

print ‘Something Moved on the Table!’

and in the touch_down callback, delete the commend and add:

print ‘Something was Placed on the Table!’

Now open your TUIO source(Touchlib, TUIO Sim).  Open a terminal, cd into the directory with hellomt.py, and run:

python ./hellomt.py

Then touch the surface.  If all goes well it should display each message when each event happens.  If IPv6 is enabled on your liblo installation, then it may take a few seconds to start up.  Give it at least 15 seconds before deciding it doesn’t work.

Assuming all went well, now you have written your first Multi-Touch application in Python!  Its not terribly useful, but its a great basis for more useful apps.  In the next tutorial(probably going to be posted tomorrow), we will get into blobIDs and coordinates of where touch events occur, then write a program using Clutter to draw circles on each point.

There are the 10mW 780nm Lasers from Aixiz.

I bought it this morning, only to arrive home and find out the bulb works!  I don’t know how much longer it will last, so I am going to wait until I am ready to mount it in my table to play with it(excluding the image warping).

A while ago I saw that openFrameworks demo where he uses openGl shaders to warp a playing video onto a white board.  I could not find the code anywhere, so I used “The GIMP” to Perspective Transform an image.  I achieved the same effect, and was able to get a picture of the earth onto a piece of paper.  Video below:

Also, I’m sorry for not commenting the code. If you have any questions about the code just leave a question in the comments, and Ill probably get back to you within a day.
At the moment the code is _really_ messy, but here is is for anyone that wants it.  I will be cleaning it up later, this is just something I hacked up in a few minutes to see if it would work.  You will need Python, PyGame and Rabbyt if you want to run it.  Here is the code link.

NOTE:  Without the desktop record app(gtk-recordmydesktop) there was zero lag, even on my crappy graphics card(NVidia 7300) and 100 items.