Python Section
Thomas Hansen
I'm afraid i have been getting in over my head with school/work at the
moment(and need to stop complaining about it ;P ). I will try my best
to get you something more complete asap. I have thought about some
things to write about and started working on some diagrams (one for
pymt architecture (if we want that) and another one explaining the
computation of rotate/scale/pan for an example of programming for
multi touch input). Here is a very rough outline of some of the
things I have been thinking about(so you can let me know in case i am
way off from what you are thinking) (any suggestions/help/rants
welcome!):
Python for multi-touch
*introduce python
*what it is/philosophy
*easy to learn, dynamic, lots of libraries, lets you worry
about the problem rather than the language
*(I think there might be a case to be made here about dynamic
languages being better suited to deal with the nature of e.g.
multi-touch and other high bandwidth user input. programs have to
handle a much larger set of possible input states and have to respond
to input in context. So creating and modifying objects and code on the
fly at run time can be very helpful. I haven't yet thought out this
argument to well though, and I might just be biased because i like
dynamic languages so much :P )
* Python multi-touch projects
* list of free python multi-touch projects and their purpose
* related modules e.g. UI modules etc.
(I dont have to write specifically about pymt..but i know it alot
better than anything else)
* Motivation for pymt
* prototyping small apps quickly to try out/experiment with interactions
* helper functions for basic stuff (drawing shapes,
loading/playing media files)
* provide direct access to OpenGL so there is no limit on visual
output if you want it
*basic intro/references to OpenGL
* pymt architechture
* the main ideas/design
* multi-touch input (TUIO, extendable to other inputs)
* basic classes
* the widget hierarchy
* the event system
Programming for multi-touch (doesnt have to be python)
* Very brief overview/progresion of systems: e.g. single display
groupware, multiple pointers, multi-touch, tangible interfaces
* Issues/differences involved in programming for multi pointer/touch
input devices vs single pointer/mouse
* some issues going from sequential to concurent inputs
* don't know how may inputs you may get
* dealing/taking advantage of much higher input bandwidth
* keeping track of state..or rather many states
* some things we can do with multi-touch that we cant do with
single pointer (e.g. control more than one variable concurrently in
relation to time for animations/relative movement)
* Handling multi-touch/TUIO events with callbacks/event_handlers
(keeping track of touchID's)
* basic intro to ideas of event based programming
* very short example script
* Tips for programming with multiple concurent input cursors
* hashmaps (python:dictionary) for keeping track of
pointer/touchID's (what is a hash function, what is a hashmap:
key/value pair)
* letting objects take 'ownership' of touches (parallels to
mouse: if button stays pressed, scrollbar keeps scrolling even if
mouse isn't on top of it anymore)
* dealing with "shaky" input (e.g tracker switches blob id while
dragging due to vision approach)
* Example: Implementing rotate/scale/move
* well known example / well defined goal for example code
* almost boring because used so much...but very good example to
see some of the complexity that arises even in working with just 2
concurrent touches/pointers
* rotate/scale/move = conformal affine transformation (sounds
more scary than it is)
* basic math angles, vectors, intersections, transformations
(references for details)
* example code (built throughout the section)
--
Thomas
rbedi100
That would be great - the sooner the better. Your outline looks great
- I think its fine to focus on PyMT, but maybe a brief overview of the
other options (the only other one I am aware of is TouchPy). The first
couple of bullet points about introducing Python and its motivation
are great - the outline looks good, including the last point about
implementing standard gestures (rotate/scale/move).
Looking forward to seeing your draft.
Thanks,
Rishi