My first post in this section

Since summer 2009 is coming i plan to propose an idea for Google Summer of Code for the NUIGroup . I plan to do a Multitouch Extension for Google Sketchup. I chose Google Sketchup due to its almost zero learning curve to start with-

Eversince I did my own setup I’ve dreamt of working on CAD using Multi touch, since it’d be easier to just touch via multiple fingers and draw whatever we have on our mind. We’ve got a lot of people on the nuigroup forums already who’ve used SU to create wonderful models.

Coming to the point, my idea is simple- :To develop an extension for Google Sketchup that’d enable CAD manipulations using Multitouch in 3D .  Some basic features: Zooming in, Panning, two touches for a line, thumb+ index figer curl for circle :can be some of the tentative gestures used to draw using TUIO inputs. Google Sketchup has a good open source based community and resources. It comes with a 1. powerful Ruby API-that’ll extend and customize SU to suit our needs 2. and a C++ SDK.

Though the idea is not on the list -> As of now i am trying to figure out the usability and community reviews for the idea.

lot of us use Google SketchUp in different ways, maybe you can share your experience-hardships you faced while using the tool , and i’d try to see if its solvable by Multitouch

Cheers !

Project Proposal: Create a QT Api, making and extension to actual QT, making it able to handle MultiTouch inputs, with new widgets which would support the operations as any MT app, like rotation, zoom, drags, and gestures, and also a Desktop Widget which would work as the DeskTop for the Apps, where the widgets would be put, as well as others programs. Also code a binding to Python, and if possible merge with the PyMt

The reason for picking specific project: Affinity with QT, Interest in GUI’s. Already researching on the project, and already started to code, 1 week ago

Activity level within the NUI Group Community: Low

Time working multi-touch, natural user interfaces, HCI and related fields.
3 months working on MT devices and with TUIO protocol, Made some improvements on the PyTuio lib, and studied gesture recognition, currently developer from MTLab (http://code.google.com/p/mtlab/)

Name: Krishnanunni .P.N

Location: Kerala, India

Educational Qualifications: Undergraduate in Computer Science and Engineering

Open Source Experience: 3 yrs experience in Python Application development. Contributed to various Python projects.

Reason for Picking Project: Have been into designing python UIs in Tk,Wx and Qt. Having used PyMT for my final year project (which was a cheap surface computer, running Ubuntu), I was working on a rough UI builder tool.

Activity within NUI Group: Ocassional IRC presence to post queries.

Project Proposal:
Building a UI Designer/Creator tool for rapidly developing MT Applications. The Tool would allow users to drag and drop widgets. Edit the widgets and their properties and also to create custom widgets. The Tool can also be used to connect actions to various signals from the user via the UI. The Tool will finally generate code which can be run directly.
The tool can be written either in Wx or Qt making it platform independent. And the generation of code can also made to work on any platform.

Its been quite some time we’ve been working on Multitouch-izing the Google SketchUp as part of Google Summer of Code 2009 project. Here’s a little survey for the community .
I believe it’ll help us do a better finished app in the end.

http://tinyurl.com/no7axe

Results of the poll shall be made public after 1 week.

Thank you all

Anirudh Sharma

Thoughts?

Unfortunately I have been so busy with school that I have been unable to find the time to make a post until now.  Here it goes…

Abstract:

The current state of TUIO implementations require the use of explicit reception of TUIO messages, rather than adhering to a generic multi-touch interface.  If the latter were possible, applications could be written to be MT compatible, not only TUIO-compatible, or [other-MT-device]-compatible.

With the creation of Multi-Pointer X (MPX), the possibility of creating Multi-Pointer native applications is possible.  To utilize these features with the currently existent TUIO trackers, though, we need a way for MPX to interface with these devices.  To do this, an xorg-input-tuio driver will be written to receive TUIO events, analyze them, and pass them along as MPX input events.

The integration of TUIO based hardware into MPX means that not only will native applications be able to be built with MT capabilities, but an MPX-enabled X-server coupled with the MT capabilties of a TUIO device will be able to interact with legacy applications.  Although new MT capabilties can’t necessarily be added to an application that doesn’t support it (gestures such as two-finger swipe scrolling could be added, though), it’s single mouse/keyboard interface will be accessible, and there will be the ability to use multiple legacy applications in a multi-user environment - e.g. two users simultaneously browsing the internet in separate windows.

Creating a basic xorg input driver alone will only be the first portion of the project.  In addition to the basic TUIO message receiving and forwarding, these are several features that are also being considered:

- Multiple trackers - this is a must.  This would provide the ability for multiple trackers to interact with the system.  Imagine an MT wall where users can walk up to it, pull out there iphone, and almost instantly interact with the wall - in addition to that, imagine users with wiimotes also interacting with the wall at the same time.
- Cropping of TUIO input (e.g. ignore input outside a certain boundary, could potentially be arbitrary, but likely rectangular)
- Joining of TUIO trackers. This would allow two trackers to appear as one.  One example might be two trackers, representing adjacent surface areas.  These areas could be joined as one.
- Setting the effective area of blobs.  If, for instance, you had 4 trackers, you could set them to effectively use 1 quarter of screen space each.  In use with joining TUIO trackers, this could lead to an ad-hoc way to do camera stitching (Having finger drags that go across two trackers may be tricky though, and should probably be left to the tracker).

In addition to these features, I also plan to create a GUI and CLI interface for the driver.  This would allow easy configuraiton and management of the driver.

This is what I have so far.  I am really excited to work on this project, so please let me know what you guys think!  Any input and/or suggestions are helpful, particularly to do with the features of the driver .

I will be posting a link to my proposal once I get a little feedback and finish it up.

Thanks!

Ryan Huffman

I use C++ in vs.2005 to develop my project.  Now I can control the google earth by my fingers but it still needs more improve.  The api I use is google earth com api.

My idea is very simple. Now I will tell the develop process of how to implement the control of google earth.

First I create a new class named TouchEarth. This class has two parts. One part is used for receive TUIO blob information from touchlib just like other MultiTouch applications. So now we can get the inputs to google earth.
The other part is the animation part. This part is used for giving corresponding presentation of google earth according to the inputs. In google earth com api(http://earth.google.com/comapi/index.html),there is a class:IApplicationGE. We need to create a instance of this class.  It has a function: SetCameraParams(double lat, double lon, double alt, AltitudeModeGE altMode, double range, double tilt, double azimuth, double speed).  In fact, this function is powerful enough to control the presentaion of google earth. Now I will give you an example:

Now in the blob list(member of TouchEarth store the receive blob information:ID, Xpos,Ypos) there is one blob. In my resolution, one finger is used for control the turning of the earth. Firstly I need to check if the blob is on the terrain of the earth ball. We have a function: IApplicationGE::GetPointOnTerrainFromScreenCoords, it can help us to confirm whether the blob is on the earth. If the return value is TRUE, the return parameters will give us the blob’s corresponding Latitude, Longitude, Altitude.  So if one finger moves on the earth ball, we can calculate the finger’s move information on the earth.  From pointA(Latitude1, Longitude1) to pointB(Latitude2, Longitude2), so we know that the earth will have a turning, the turning difference is posAB(Latitude1-Latitude2, Longitude1-Longitude2).

There is a function:IApplicationGE::GetCamera (BOOL considerTerrain, ICameraInfoGE ** pCamera), This function can return current camera parameters of the earth. So what I need to do is:

IApplicationGE geapp;
geapp.GetCamera(1, pCamera);
double lat = pcamera.lat;
double lon = pcamera.lon;
SetCameraParams(pCamera.lat + Latitude1-Latitude2, pCamera.lon + Longitude1-Longitude2, pCamera.alt, pCamera.altMode, pCamera.range, pCamera.tilt, pCamera.azimuth, pCamera.speed) ;

It is very simple, isn’t it?
The way to control the zoom in and zoom out is similar, we just need to calculate the difference of pCamera.range.
That is my ideas. Hope can help someone who need help.
I am a developer in Beijing China. My English is not as good as to express my whole idea clearly. Anyone is welcome to contact me. My email(gtalk) is:hit1943@gmail.com