pandory500/SDL-mirror
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Fixed bugs related to keyboard handling in gestureSDLTest. Fixed gesture code (dynamic memory allocation). Cleaned up gesture and test code.

Browse source
This commit is contained in:
Jim Grandpre 2010-08-13 23:08:32 -04:00
parent c26da073d3
commit 68b3cfb42f
2 changed files with 186 additions and 334 deletions
Download patch file Download diff file Expand all files Collapse all files

243
src/events/SDL_gesture.c
View file

@ -27,11 +27,12 @@
#include "SDL_gesture_c.h" #include "SDL_gesture_c.h"
//TODO: Replace with malloc //TODO: Replace with malloc
#define MAXFINGERS 5
#define MAXTOUCHES 2
#define MAXTEMPLATES 4
#define MAXPATHSIZE 1024 #define MAXPATHSIZE 1024
#define DOLLARNPOINTS 64 #define DOLLARNPOINTS 64
#define DOLLARSIZE 256 #define DOLLARSIZE 256
@ -42,55 +43,38 @@
typedef struct { typedef struct {
float x,y; float x,y;
} Point; } SDL_FloatPoint;
typedef struct {
Point p;
float pressure;
SDL_FingerID id;
} Finger;
typedef struct { typedef struct {
float length; float length;
int numPoints; int numPoints;
Point p[MAXPATHSIZE]; SDL_FloatPoint p[MAXPATHSIZE];
} DollarPath; } SDL_DollarPath;
/*
typedef struct { typedef struct {
Finger f; SDL_FloatPoint path[DOLLARNPOINTS];
Point cv;
float dtheta,dDist;
DollarPath dollarPath;
} TouchPoint;
*/
typedef struct {
Point path[DOLLARNPOINTS];
unsigned long hash; unsigned long hash;
} DollarTemplate; } SDL_DollarTemplate;
typedef struct { typedef struct {
SDL_GestureID id; SDL_GestureID id;
Point res; SDL_FloatPoint res;
Point centroid; SDL_FloatPoint centroid;
//TouchPoint gestureLast[MAXFINGERS]; SDL_DollarPath dollarPath;
DollarPath dollarPath;
Uint16 numDownFingers; Uint16 numDownFingers;
int numDollarTemplates; int numDollarTemplates;
DollarTemplate dollarTemplate[MAXTEMPLATES]; SDL_DollarTemplate *dollarTemplate;
SDL_bool recording; SDL_bool recording;
} GestureTouch; } SDL_GestureTouch;
GestureTouch gestureTouch[MAXTOUCHES]; SDL_GestureTouch *SDL_gestureTouch;
int numGestureTouches = 0; int SDL_numGestureTouches = 0;
SDL_bool recordAll; SDL_bool recordAll;
void SDL_PrintPath(Point *path) { void SDL_PrintPath(SDL_FloatPoint *path) {
int i; int i;
printf("Path:"); printf("Path:");
for(i=0;i<DOLLARNPOINTS;i++) { for(i=0;i<DOLLARNPOINTS;i++) {
@ -102,9 +86,9 @@ void SDL_PrintPath(Point *path) {
int SDL_RecordGesture(SDL_TouchID touchId) { int SDL_RecordGesture(SDL_TouchID touchId) {
int i; int i;
if(touchId < 0) recordAll = SDL_TRUE; if(touchId < 0) recordAll = SDL_TRUE;
for(i = 0;i < numGestureTouches; i++) { for(i = 0;i < SDL_numGestureTouches; i++) {
if((touchId < 0) || (gestureTouch[i].id == touchId)) { if((touchId < 0) || (SDL_gestureTouch[i].id == touchId)) {
gestureTouch[i].recording = SDL_TRUE; SDL_gestureTouch[i].recording = SDL_TRUE;
if(touchId >= 0) if(touchId >= 0)
return 1; return 1;
} }
@ -112,7 +96,7 @@ int SDL_RecordGesture(SDL_TouchID touchId) {
return (touchId < 0); return (touchId < 0);
} }
unsigned long SDL_HashDollar(Point* points) { unsigned long SDL_HashDollar(SDL_FloatPoint* points) {
unsigned long hash = 5381; unsigned long hash = 5381;
int i; int i;
for(i = 0;i < DOLLARNPOINTS; i++) { for(i = 0;i < DOLLARNPOINTS; i++) {
@ -123,7 +107,7 @@ unsigned long SDL_HashDollar(Point* points) {
} }
static int SaveTemplate(DollarTemplate *templ, SDL_RWops * src) { static int SaveTemplate(SDL_DollarTemplate *templ, SDL_RWops * src) {
if(src == NULL) return 0; if(src == NULL) return 0;
int i; int i;
@ -141,8 +125,8 @@ static int SaveTemplate(DollarTemplate *templ, SDL_RWops * src) {
int SDL_SaveAllDollarTemplates(SDL_RWops *src) { int SDL_SaveAllDollarTemplates(SDL_RWops *src) {
int i,j,rtrn = 0; int i,j,rtrn = 0;
for(i = 0; i < numGestureTouches; i++) { for(i = 0; i < SDL_numGestureTouches; i++) {
GestureTouch* touch = &gestureTouch[i]; SDL_GestureTouch* touch = &SDL_gestureTouch[i];
for(j = 0;j < touch->numDollarTemplates; j++) { for(j = 0;j < touch->numDollarTemplates; j++) {
rtrn += SaveTemplate(&touch->dollarTemplate[i],src); rtrn += SaveTemplate(&touch->dollarTemplate[i],src);
} }
@ -152,8 +136,8 @@ int SDL_SaveAllDollarTemplates(SDL_RWops *src) {
int SDL_SaveDollarTemplate(SDL_GestureID gestureId, SDL_RWops *src) { int SDL_SaveDollarTemplate(SDL_GestureID gestureId, SDL_RWops *src) {
int i,j; int i,j;
for(i = 0; i < numGestureTouches; i++) { for(i = 0; i < SDL_numGestureTouches; i++) {
GestureTouch* touch = &gestureTouch[i]; SDL_GestureTouch* touch = &SDL_gestureTouch[i];
for(j = 0;j < touch->numDollarTemplates; j++) { for(j = 0;j < touch->numDollarTemplates; j++) {
if(touch->dollarTemplate[i].hash == gestureId) { if(touch->dollarTemplate[i].hash == gestureId) {
return SaveTemplate(&touch->dollarTemplate[i],src); return SaveTemplate(&touch->dollarTemplate[i],src);
@ -166,25 +150,46 @@ int SDL_SaveDollarTemplate(SDL_GestureID gestureId, SDL_RWops *src) {
//path is an already sampled set of points //path is an already sampled set of points
//Returns the index of the gesture on success, or -1 //Returns the index of the gesture on success, or -1
static int SDL_AddDollarGesture(GestureTouch* inTouch,Point* path) { static int SDL_AddDollarGesture(SDL_GestureTouch* inTouch,SDL_FloatPoint* path) {
if(inTouch == NULL) { if(inTouch == NULL) {
if(numGestureTouches == 0) return -1; if(SDL_numGestureTouches == 0) return -1;
int i = 0; int i = 0;
for(i = 0;i < numGestureTouches; i++) { for(i = 0;i < SDL_numGestureTouches; i++) {
inTouch = &gestureTouch[i]; inTouch = &SDL_gestureTouch[i];
if(inTouch->numDollarTemplates < MAXTEMPLATES) {
DollarTemplate *templ = SDL_DollarTemplate* dollarTemplate =
SDL_realloc(inTouch->dollarTemplate,
(inTouch->numDollarTemplates + 1) *
sizeof(SDL_DollarTemplate));
if(!dollarTemplate) {
SDL_OutOfMemory();
return -1;
}
inTouch->dollarTemplate = dollarTemplate;
SDL_DollarTemplate *templ =
&inTouch->dollarTemplate[inTouch->numDollarTemplates]; &inTouch->dollarTemplate[inTouch->numDollarTemplates];
memcpy(templ->path,path,DOLLARNPOINTS*sizeof(Point)); memcpy(templ->path,path,DOLLARNPOINTS*sizeof(SDL_FloatPoint));
templ->hash = SDL_HashDollar(templ->path); templ->hash = SDL_HashDollar(templ->path);
inTouch->numDollarTemplates++; inTouch->numDollarTemplates++;
} }
}
return inTouch->numDollarTemplates - 1; return inTouch->numDollarTemplates - 1;
}else if(inTouch->numDollarTemplates < MAXTEMPLATES) { } else {
DollarTemplate *templ = SDL_DollarTemplate* dollarTemplate =
SDL_realloc(inTouch->dollarTemplate,
(inTouch->numDollarTemplates + 1) *
sizeof(SDL_DollarTemplate));
if(!dollarTemplate) {
SDL_OutOfMemory();
return -1;
}
inTouch->dollarTemplate = dollarTemplate;
SDL_DollarTemplate *templ =
&inTouch->dollarTemplate[inTouch->numDollarTemplates]; &inTouch->dollarTemplate[inTouch->numDollarTemplates];
memcpy(templ->path,path,DOLLARNPOINTS*sizeof(Point)); memcpy(templ->path,path,DOLLARNPOINTS*sizeof(SDL_FloatPoint));
templ->hash = SDL_HashDollar(templ->path); templ->hash = SDL_HashDollar(templ->path);
inTouch->numDollarTemplates++; inTouch->numDollarTemplates++;
return inTouch->numDollarTemplates - 1; return inTouch->numDollarTemplates - 1;
@ -195,36 +200,28 @@ static int SDL_AddDollarGesture(GestureTouch* inTouch,Point* path) {
int SDL_LoadDollarTemplates(SDL_TouchID touchId, SDL_RWops *src) { int SDL_LoadDollarTemplates(SDL_TouchID touchId, SDL_RWops *src) {
if(src == NULL) return 0; if(src == NULL) return 0;
int i,loaded = 0; int i,loaded = 0;
GestureTouch *touch = NULL; SDL_GestureTouch *touch = NULL;
if(touchId >= 0) { if(touchId >= 0) {
for(i = 0;i < numGestureTouches; i++) for(i = 0;i < SDL_numGestureTouches; i++)
if(gestureTouch[i].id == touchId) if(SDL_gestureTouch[i].id == touchId)
touch = &gestureTouch[i]; touch = &SDL_gestureTouch[i];
if(touch == NULL) return -1; if(touch == NULL) return -1;
} }
while(1) { while(1) {
DollarTemplate templ; SDL_DollarTemplate templ;
//fscanf(fp,"%lu ",&templ.hash);
/* if(SDL_RWread(src,templ.path,sizeof(templ.path[0]),DOLLARNPOINTS) <
for(i = 0;i < DOLLARNPOINTS; i++) { DOLLARNPOINTS) break;
int x,y;
if(fscanf(fp,"%i %i ",&x,&y) != 2) break;
templ.path[i].x = x;
templ.path[i].y = y;
}
fscanf(fp,"\n");
*/
if(SDL_RWread(src,templ.path,sizeof(templ.path[0]),DOLLARNPOINTS) < DOLLARNPOINTS) break;
if(touchId >= 0) { if(touchId >= 0) {
printf("Adding loaded gesture to 1 touch\n"); printf("Adding loaded gesture to 1 touch\n");
if(SDL_AddDollarGesture(touch,templ.path)) loaded++; if(SDL_AddDollarGesture(touch,templ.path)) loaded++;
} }
else { else {
printf("Adding to: %i touches\n",numGestureTouches); printf("Adding to: %i touches\n",SDL_numGestureTouches);
for(i = 0;i < numGestureTouches; i++) { for(i = 0;i < SDL_numGestureTouches; i++) {
touch = &gestureTouch[i]; touch = &SDL_gestureTouch[i];
printf("Adding loaded gesture to + touches\n"); printf("Adding loaded gesture to + touches\n");
//TODO: What if this fails? //TODO: What if this fails?
SDL_AddDollarGesture(touch,templ.path); SDL_AddDollarGesture(touch,templ.path);
@ -237,10 +234,10 @@ int SDL_LoadDollarTemplates(SDL_TouchID touchId, SDL_RWops *src) {
} }
float dollarDifference(Point* points,Point* templ,float ang) { float dollarDifference(SDL_FloatPoint* points,SDL_FloatPoint* templ,float ang) {
// Point p[DOLLARNPOINTS]; // SDL_FloatPoint p[DOLLARNPOINTS];
float dist = 0; float dist = 0;
Point p; SDL_FloatPoint p;
int i; int i;
for(i = 0; i < DOLLARNPOINTS; i++) { for(i = 0; i < DOLLARNPOINTS; i++) {
p.x = points[i].x * cos(ang) - points[i].y * sin(ang); p.x = points[i].x * cos(ang) - points[i].y * sin(ang);
@ -252,7 +249,7 @@ float dollarDifference(Point* points,Point* templ,float ang) {
} }
float bestDollarDifference(Point* points,Point* templ) { float bestDollarDifference(SDL_FloatPoint* points,SDL_FloatPoint* templ) {
//------------BEGIN DOLLAR BLACKBOX----------------// //------------BEGIN DOLLAR BLACKBOX----------------//
//-TRANSLATED DIRECTLY FROM PSUDEO-CODE AVAILABLE AT-// //-TRANSLATED DIRECTLY FROM PSUDEO-CODE AVAILABLE AT-//
//-"http://depts.washington.edu/aimgroup/proj/dollar/"-// //-"http://depts.washington.edu/aimgroup/proj/dollar/"-//
@ -289,10 +286,9 @@ float bestDollarDifference(Point* points,Point* templ) {
} }
//DollarPath contains raw points, plus (possibly) the calculated length //DollarPath contains raw points, plus (possibly) the calculated length
int dollarNormalize(DollarPath path,Point *points) { int dollarNormalize(SDL_DollarPath path,SDL_FloatPoint *points) {
int i; int i;
//Calculate length if it hasn't already been done //Calculate length if it hasn't already been done
printf("length: %f\n",path.length);
if(path.length <= 0) { if(path.length <= 0) {
for(i=1;i<path.numPoints;i++) { for(i=1;i<path.numPoints;i++) {
float dx = path.p[i ].x - float dx = path.p[i ].x -
@ -302,14 +298,13 @@ int dollarNormalize(DollarPath path,Point *points) {
path.length += sqrt(dx*dx+dy*dy); path.length += sqrt(dx*dx+dy*dy);
} }
} }
printf("New length: %f\n",path.length);
//Resample //Resample
float interval = path.length/(DOLLARNPOINTS - 1); float interval = path.length/(DOLLARNPOINTS - 1);
float dist = interval; float dist = interval;
int numPoints = 0; int numPoints = 0;
Point centroid; SDL_FloatPoint centroid;
centroid.x = 0;centroid.y = 0; centroid.x = 0;centroid.y = 0;
//printf("(%f,%f)\n",path.p[path.numPoints-1].x,path.p[path.numPoints-1].y); //printf("(%f,%f)\n",path.p[path.numPoints-1].x,path.p[path.numPoints-1].y);
@ -378,9 +373,9 @@ int dollarNormalize(DollarPath path,Point *points) {
return numPoints; return numPoints;
} }
float dollarRecognize(DollarPath path,int *bestTempl,GestureTouch* touch) { float dollarRecognize(SDL_DollarPath path,int *bestTempl,SDL_GestureTouch* touch) {
Point points[DOLLARNPOINTS]; SDL_FloatPoint points[DOLLARNPOINTS];
int numPoints = dollarNormalize(path,points); int numPoints = dollarNormalize(path,points);
//SDL_PrintPath(points); //SDL_PrintPath(points);
int i; int i;
@ -395,33 +390,55 @@ float dollarRecognize(DollarPath path,int *bestTempl,GestureTouch* touch) {
} }
int SDL_GestureAddTouch(SDL_Touch* touch) { int SDL_GestureAddTouch(SDL_Touch* touch) {
if(numGestureTouches >= MAXTOUCHES) return -1; SDL_GestureTouch *gestureTouch = SDL_realloc(SDL_gestureTouch,
(SDL_numGestureTouches + 1) *
sizeof(SDL_GestureTouch));
gestureTouch[numGestureTouches].res.x = touch->xres; if(!gestureTouch) {
gestureTouch[numGestureTouches].res.y = touch->yres; SDL_OutOfMemory();
gestureTouch[numGestureTouches].numDownFingers = 0; return -1;
}
gestureTouch[numGestureTouches].res.x = touch->xres; SDL_gestureTouch = gestureTouch;
gestureTouch[numGestureTouches].id = touch->id;
gestureTouch[numGestureTouches].numDollarTemplates = 0; SDL_gestureTouch[SDL_numGestureTouches].res.x = touch->xres;
SDL_gestureTouch[SDL_numGestureTouches].res.y = touch->yres;
SDL_gestureTouch[SDL_numGestureTouches].numDownFingers = 0;
gestureTouch[numGestureTouches].recording = SDL_FALSE; SDL_gestureTouch[SDL_numGestureTouches].res.x = touch->xres;
SDL_gestureTouch[SDL_numGestureTouches].id = touch->id;
numGestureTouches++; SDL_gestureTouch[SDL_numGestureTouches].numDollarTemplates = 0;
SDL_gestureTouch[SDL_numGestureTouches].recording = SDL_FALSE;
SDL_numGestureTouches++;
return 0; return 0;
} }
GestureTouch * SDL_GetGestureTouch(SDL_TouchID id) { int SDL_GestureRemoveTouch(SDL_TouchID id) {
int i; int i;
for(i = 0;i < numGestureTouches; i++) { for(i = 0;i < SDL_numGestureTouches; i++) {
//printf("%i ?= %i\n",gestureTouch[i].id,id); if(SDL_gestureTouch[i].id == id) {
if(gestureTouch[i].id == id) return &gestureTouch[i]; SDL_numGestureTouches--;
SDL_gestureTouch[i] = SDL_gestureTouch[SDL_numGestureTouches];
return 1;
}
}
return -1;
}
SDL_GestureTouch * SDL_GetGestureTouch(SDL_TouchID id) {
int i;
for(i = 0;i < SDL_numGestureTouches; i++) {
//printf("%i ?= %i\n",SDL_gestureTouch[i].id,id);
if(SDL_gestureTouch[i].id == id) return &SDL_gestureTouch[i];
} }
return NULL; return NULL;
} }
int SDL_SendGestureMulti(GestureTouch* touch,float dTheta,float dDist) { int SDL_SendGestureMulti(SDL_GestureTouch* touch,float dTheta,float dDist) {
SDL_Event event; SDL_Event event;
event.mgesture.type = SDL_MULTIGESTURE; event.mgesture.type = SDL_MULTIGESTURE;
event.mgesture.touchId = touch->id; event.mgesture.touchId = touch->id;
@ -433,7 +450,7 @@ int SDL_SendGestureMulti(GestureTouch* touch,float dTheta,float dDist) {
return SDL_PushEvent(&event) > 0; return SDL_PushEvent(&event) > 0;
} }
int SDL_SendGestureDollar(GestureTouch* touch, int SDL_SendGestureDollar(SDL_GestureTouch* touch,
SDL_GestureID gestureId,float error) { SDL_GestureID gestureId,float error) {
SDL_Event event; SDL_Event event;
event.dgesture.type = SDL_DOLLARGESTURE; event.dgesture.type = SDL_DOLLARGESTURE;
@ -449,7 +466,7 @@ int SDL_SendGestureDollar(GestureTouch* touch,
} }
int SDL_SendDollarRecord(GestureTouch* touch,SDL_GestureID gestureId) { int SDL_SendDollarRecord(SDL_GestureTouch* touch,SDL_GestureID gestureId) {
SDL_Event event; SDL_Event event;
event.dgesture.type = SDL_DOLLARRECORD; event.dgesture.type = SDL_DOLLARRECORD;
event.dgesture.touchId = touch->id; event.dgesture.touchId = touch->id;
@ -464,7 +481,7 @@ void SDL_GestureProcessEvent(SDL_Event* event)
if(event->type == SDL_FINGERMOTION || if(event->type == SDL_FINGERMOTION ||
event->type == SDL_FINGERDOWN || event->type == SDL_FINGERDOWN ||
event->type == SDL_FINGERUP) { event->type == SDL_FINGERUP) {
GestureTouch* inTouch = SDL_GetGestureTouch(event->tfinger.touchId); SDL_GestureTouch* inTouch = SDL_GetGestureTouch(event->tfinger.touchId);
//Shouldn't be possible //Shouldn't be possible
if(inTouch == NULL) return; if(inTouch == NULL) return;
@ -485,15 +502,15 @@ void SDL_GestureProcessEvent(SDL_Event* event)
#ifdef ENABLE_DOLLAR #ifdef ENABLE_DOLLAR
if(inTouch->recording) { if(inTouch->recording) {
inTouch->recording = SDL_FALSE; inTouch->recording = SDL_FALSE;
Point path[DOLLARNPOINTS]; SDL_FloatPoint path[DOLLARNPOINTS];
dollarNormalize(inTouch->dollarPath,path); dollarNormalize(inTouch->dollarPath,path);
//SDL_PrintPath(path); //SDL_PrintPath(path);
int index; int index;
if(recordAll) { if(recordAll) {
index = SDL_AddDollarGesture(NULL,path); index = SDL_AddDollarGesture(NULL,path);
int i; int i;
for(i = 0;i < numGestureTouches; i++) for(i = 0;i < SDL_numGestureTouches; i++)
gestureTouch[i].recording = SDL_FALSE; SDL_gestureTouch[i].recording = SDL_FALSE;
} }
else { else {
index = SDL_AddDollarGesture(inTouch,path); index = SDL_AddDollarGesture(inTouch,path);
@ -532,7 +549,7 @@ void SDL_GestureProcessEvent(SDL_Event* event)
float dy = ((float)event->tfinger.dy)/(float)inTouch->res.y; float dy = ((float)event->tfinger.dy)/(float)inTouch->res.y;
//printf("dx,dy: (%f,%f)\n",dx,dy); //printf("dx,dy: (%f,%f)\n",dx,dy);
#ifdef ENABLE_DOLLAR #ifdef ENABLE_DOLLAR
DollarPath* path = &inTouch->dollarPath; SDL_DollarPath* path = &inTouch->dollarPath;
if(path->numPoints < MAXPATHSIZE) { if(path->numPoints < MAXPATHSIZE) {
path->p[path->numPoints].x = inTouch->centroid.x; path->p[path->numPoints].x = inTouch->centroid.x;
path->p[path->numPoints].y = inTouch->centroid.y; path->p[path->numPoints].y = inTouch->centroid.y;
@ -544,18 +561,18 @@ void SDL_GestureProcessEvent(SDL_Event* event)
path->numPoints++; path->numPoints++;
} }
#endif #endif
Point lastP; SDL_FloatPoint lastP;
lastP.x = x - dx; lastP.x = x - dx;
lastP.y = y - dy; lastP.y = y - dy;
Point lastCentroid; SDL_FloatPoint lastCentroid;
lastCentroid = inTouch->centroid; lastCentroid = inTouch->centroid;
inTouch->centroid.x += dx/inTouch->numDownFingers; inTouch->centroid.x += dx/inTouch->numDownFingers;
inTouch->centroid.y += dy/inTouch->numDownFingers; inTouch->centroid.y += dy/inTouch->numDownFingers;
//printf("Centrid : (%f,%f)\n",inTouch->centroid.x,inTouch->centroid.y); //printf("Centrid : (%f,%f)\n",inTouch->centroid.x,inTouch->centroid.y);
if(inTouch->numDownFingers > 1) { if(inTouch->numDownFingers > 1) {
Point lv; //Vector from centroid to last x,y position SDL_FloatPoint lv; //Vector from centroid to last x,y position
Point v; //Vector from centroid to current x,y position SDL_FloatPoint v; //Vector from centroid to current x,y position
//lv = inTouch->gestureLast[j].cv; //lv = inTouch->gestureLast[j].cv;
lv.x = lastP.x - lastCentroid.x; lv.x = lastP.x - lastCentroid.x;
lv.y = lastP.y - lastCentroid.y; lv.y = lastP.y - lastCentroid.y;
@ -608,15 +625,9 @@ void SDL_GestureProcessEvent(SDL_Event* event)
x)/inTouch->numDownFingers; x)/inTouch->numDownFingers;
inTouch->centroid.y = (inTouch->centroid.y*(inTouch->numDownFingers - 1)+ inTouch->centroid.y = (inTouch->centroid.y*(inTouch->numDownFingers - 1)+
y)/inTouch->numDownFingers; y)/inTouch->numDownFingers;
printf("Finger Down: (%f,%f). Centroid: (%f,%f\n",x,y, //printf("Finger Down: (%f,%f). Centroid: (%f,%f\n",x,y,
inTouch->centroid.x,inTouch->centroid.y); // inTouch->centroid.x,inTouch->centroid.y);
/*
inTouch->gestureLast[j].f.id = event->tfinger.fingerId;
inTouch->gestureLast[j].f.p.x = x;
inTouch->gestureLast[j].f.p.y = y;
inTouch->gestureLast[j].cv.x = 0;
inTouch->gestureLast[j].cv.y = 0;
*/
#ifdef ENABLE_DOLLAR #ifdef ENABLE_DOLLAR
inTouch->dollarPath.length = 0; inTouch->dollarPath.length = 0;
inTouch->dollarPath.p[0].x = x; inTouch->dollarPath.p[0].x = x;

235
touchTest/gestureSDLTest.c
View file

@ -26,63 +26,26 @@
#endif #endif
#endif #endif
#define PI 3.1415926535897
#define PHI ((sqrt(5)-1)/2)
#define WIDTH 640 #define WIDTH 640
#define HEIGHT 480 #define HEIGHT 480
#define BPP 4 #define BPP 4
#define DEPTH 32 #define DEPTH 32
#define MAXFINGERS 5
#define DOLLARNPOINTS 64
#define DOLLARSIZE 256
//MUST BE A POWER OF 2! //MUST BE A POWER OF 2!
#define EVENT_BUF_SIZE 256 #define EVENT_BUF_SIZE 256
#define VERBOSE SDL_FALSE
SDL_Event events[EVENT_BUF_SIZE]; SDL_Event events[EVENT_BUF_SIZE];
int eventWrite; int eventWrite;
int mousx,mousy;
int keystat[512];
int bstatus;
int colors[7] = {0xFF,0xFF00,0xFF0000,0xFFFF00,0x00FFFF,0xFF00FF,0xFFFFFF}; int colors[7] = {0xFF,0xFF00,0xFF0000,0xFFFF00,0x00FFFF,0xFF00FF,0xFFFFFF};
SDL_FingerID index2fingerid[MAXFINGERS];
int fingersDown;
typedef struct { typedef struct {
float x,y; float x,y;
} Point; } Point;
typedef struct {
Point p;
float pressure;
SDL_FingerID id;
} Finger;
typedef struct {
Finger f;
Point cv;
float dtheta,dDist;
} TouchPoint;
typedef struct { //dt + s
Point d,s; //direction, start
int points;
} Line;
typedef struct {
float length;
int numPoints;
Point p[EVENT_BUF_SIZE]; //To be safe
} DollarPath;
typedef struct { typedef struct {
float ang,r; float ang,r;
Point p; Point p;
@ -90,19 +53,6 @@ typedef struct {
Knob knob; Knob knob;
Finger finger[MAXFINGERS];
DollarPath dollarPath[MAXFINGERS];
#define MAXTEMPLATES 4
Point dollarTemplate[MAXTEMPLATES][DOLLARNPOINTS];
int numDollarTemplates = 0;
#ifdef DRAW_VECTOR_EST
Line gestureLine[MAXFINGERS];
#endif
void handler (int sig) void handler (int sig)
{ {
printf ("\exiting...(%d)\n", sig); printf ("\exiting...(%d)\n", sig);
@ -115,7 +65,6 @@ void perror_exit (char *error)
handler (9); handler (9);
} }
void setpix(SDL_Surface *screen, int x, int y, unsigned int col) void setpix(SDL_Surface *screen, int x, int y, unsigned int col)
{ {
Uint32 *pixmem32; Uint32 *pixmem32;
@ -150,13 +99,10 @@ void drawLine(SDL_Surface *screen,int x0,int y0,int x1,int y1,unsigned int col)
for(t=0;t<1;t+=1.f/SDL_max(abs(x0-x1),abs(y0-y1))) for(t=0;t<1;t+=1.f/SDL_max(abs(x0-x1),abs(y0-y1)))
setpix(screen,x1+t*(x0-x1),y1+t*(y0-y1),col); setpix(screen,x1+t*(x0-x1),y1+t*(y0-y1),col);
} }
void drawCircle(SDL_Surface* screen,int x,int y,int r,unsigned int c) void drawCircle(SDL_Surface* screen,int x,int y,int r,unsigned int c)
{ {
int tx,ty;
float a;
int tx;
int ty;
float xr; float xr;
for(ty = -abs(r);ty <= abs(r);ty++) { for(ty = -abs(r);ty <= abs(r);ty++) {
xr = sqrt(r*r - ty*ty); xr = sqrt(r*r - ty*ty);
@ -173,50 +119,24 @@ void drawCircle(SDL_Surface* screen,int x,int y,int r,unsigned int c)
} }
void drawKnob(SDL_Surface* screen,Knob k) { void drawKnob(SDL_Surface* screen,Knob k) {
//printf("Knob: x = %f, y = %f, r = %f, a = %f\n",k.p.x,k.p.y,k.r,k.ang);
drawCircle(screen,k.p.x*screen->w,k.p.y*screen->h,k.r*screen->w,0xFFFFFF); drawCircle(screen,k.p.x*screen->w,k.p.y*screen->h,k.r*screen->w,0xFFFFFF);
drawCircle(screen,(k.p.x+k.r/2*cos(k.ang))*screen->w, drawCircle(screen,(k.p.x+k.r/2*cos(k.ang))*screen->w,
(k.p.y+k.r/2*sin(k.ang))*screen->h,k.r/4*screen->w,0); (k.p.y+k.r/2*sin(k.ang))*screen->h,k.r/4*screen->w,0);
} }
void DrawScreen(SDL_Surface* screen, int h) void DrawScreen(SDL_Surface* screen)
{ {
int x, y, xm,ym,c; int x, y;
if(SDL_MUSTLOCK(screen)) if(SDL_MUSTLOCK(screen))
{ {
if(SDL_LockSurface(screen) < 0) return; if(SDL_LockSurface(screen) < 0) return;
} }
for(y = 0;y < screen->h;y++) for(y = 0;y < screen->h;y++)
{
for(x = 0;x < screen->w;x++) for(x = 0;x < screen->w;x++)
{
//setpixel(screen, x, y, (x*x)/256+3*y+h, (y*y)/256+x+h, h);
//xm = (x+h)%screen->w;
//ym = (y+h)%screen->w;
//c = sin(h/256*2*PI)*x*y/screen->w/screen->h;
//setpix(screen,x,y,255*sin(xm/screen->w*2*PI),sin(h/255*2*PI)*255*y/screen->h,c);
setpix(screen,x,y,((x%255)<<16) + ((y%255)<<8) + (x+y)%255); setpix(screen,x,y,((x%255)<<16) + ((y%255)<<8) + (x+y)%255);
//setpix(screen,x,y,0); //Inefficient, but that's okay...
}
}
drawCircle(screen,mousx,mousy,-30,0xFFFFFF);
drawLine(screen,0,0,screen->w,screen->h,0xFFFFFF);
int i; int i;
//draw Touch History //draw Touch History
TouchPoint gestureLast[MAXFINGERS];
//printf("------------------Start History------------------\n");
for(i = 0;i < MAXFINGERS;i++) {
gestureLast[i].f.id = -1;
}
int numDownFingers = 0;
Point centroid;
float gdtheta,gdDist;
for(i = SDL_max(0,eventWrite - EVENT_BUF_SIZE);i < eventWrite;i++) { for(i = SDL_max(0,eventWrite - EVENT_BUF_SIZE);i < eventWrite;i++) {
SDL_Event event = events[i&(EVENT_BUF_SIZE-1)]; SDL_Event event = events[i&(EVENT_BUF_SIZE-1)];
int age = eventWrite - i - 1; int age = eventWrite - i - 1;
@ -224,13 +144,12 @@ void DrawScreen(SDL_Surface* screen, int h)
event.type == SDL_FINGERDOWN || event.type == SDL_FINGERDOWN ||
event.type == SDL_FINGERUP) { event.type == SDL_FINGERUP) {
SDL_Touch* inTouch = SDL_GetTouch(event.tfinger.touchId); SDL_Touch* inTouch = SDL_GetTouch(event.tfinger.touchId);
//SDL_Finger* inFinger = SDL_GetFinger(inTouch,event.tfinger.fingerId); if(inTouch == NULL) continue;
float x = ((float)event.tfinger.x)/inTouch->xres; float x = ((float)event.tfinger.x)/inTouch->xres;
float y = ((float)event.tfinger.y)/inTouch->yres; float y = ((float)event.tfinger.y)/inTouch->yres;
//draw the touch: //draw the touch:
unsigned int c = colors[event.tfinger.touchId%7]; unsigned int c = colors[event.tfinger.touchId%7];
unsigned int col = unsigned int col =
((unsigned int)(c*(.1+.85))) | ((unsigned int)(c*(.1+.85))) |
@ -243,25 +162,10 @@ void DrawScreen(SDL_Surface* screen, int h)
} }
} }
/*
for(i=0;i<MAXFINGERS;i++)
if(finger[i].p.x >= 0 && finger[i].p.y >= 0)
if(finger[i].pressure > 0)
drawCircle(screen,finger[i].p.x*screen->w,finger[i].p.y*screen->h
,20,0xFF*finger[i].pressure);
else
drawCircle(screen,finger[i].p.x*screen->w,finger[i].p.y*screen->h
,20,0xFF);
*/
keystat[32] = 0;
if(knob.p.x > 0) if(knob.p.x > 0)
drawKnob(screen,knob); drawKnob(screen,knob);
if(SDL_MUSTLOCK(screen)) SDL_UnlockSurface(screen); if(SDL_MUSTLOCK(screen)) SDL_UnlockSurface(screen);
SDL_Flip(screen); SDL_Flip(screen);
} }
@ -276,20 +180,14 @@ int main(int argc, char* argv[])
SDL_Surface *screen; SDL_Surface *screen;
SDL_Event event; SDL_Event event;
int keypress = 0;
int h=0,s=1,i,j;
//gesture variables //gesture variables
int numDownFingers = 0;
float gdtheta = 0,gdDist = 0;
Point centroid;
knob.r = .1; knob.r = .1;
knob.ang = 0; knob.ang = 0;
TouchPoint gestureLast[MAXFINGERS];
SDL_bool quitting = SDL_FALSE;
SDL_RWops *src;
memset(keystat,0,512*sizeof(keystat[0]));
if (SDL_Init(SDL_INIT_VIDEO) < 0 ) return 1; if (SDL_Init(SDL_INIT_VIDEO) < 0 ) return 1;
if (!(screen = initScreen(WIDTH,HEIGHT))) if (!(screen = initScreen(WIDTH,HEIGHT)))
@ -298,8 +196,7 @@ int main(int argc, char* argv[])
return 1; return 1;
} }
while(!keystat[27]) { while(!quitting) {
//Poll SDL
while(SDL_PollEvent(&event)) while(SDL_PollEvent(&event))
{ {
//Record _all_ events //Record _all_ events
@ -309,38 +206,28 @@ int main(int argc, char* argv[])
switch (event.type) switch (event.type)
{ {
case SDL_QUIT: case SDL_QUIT:
keystat[27] = 1; quitting = SDL_TRUE;
break; break;
case SDL_KEYDOWN: case SDL_KEYDOWN:
//printf("%i\n",event.key.keysym.sym); switch (event.key.keysym.sym)
keystat[event.key.keysym.sym] = 1; {
if(event.key.keysym.sym == 32) { case SDLK_SPACE:
SDL_RecordGesture(-1); SDL_RecordGesture(-1);
} break;
else if(event.key.keysym.sym == 115) { case SDLK_s:
SDL_RWops *src;
//fp = fopen("gestureSave","w");
src = SDL_RWFromFile("gestureSave","w"); src = SDL_RWFromFile("gestureSave","w");
printf("Wrote %i templates\n",SDL_SaveAllDollarTemplates(src)); printf("Wrote %i templates\n",SDL_SaveAllDollarTemplates(src));
//fclose(fp);
SDL_RWclose(src); SDL_RWclose(src);
} break;
else if(event.key.keysym.sym == 108) { case SDLK_l:
SDL_RWops *src;
//fp = fopen("gestureSave","r");
src = SDL_RWFromFile("gestureSave","r"); src = SDL_RWFromFile("gestureSave","r");
printf("Loaded: %i\n",SDL_LoadDollarTemplates(-1,src)); printf("Loaded: %i\n",SDL_LoadDollarTemplates(-1,src));
//fclose(fp);
SDL_RWclose(src); SDL_RWclose(src);
}
//keypress = 1;
break; break;
case SDL_KEYUP: case SDLK_ESCAPE:
//printf("%i\n",event.key.keysym.sym); quitting = SDL_TRUE;
keystat[event.key.keysym.sym] = 0; break;
//keypress = 1; }
break; break;
case SDL_VIDEORESIZE: case SDL_VIDEORESIZE:
if (!(screen = initScreen(event.resize.w, if (!(screen = initScreen(event.resize.w,
@ -350,78 +237,36 @@ int main(int argc, char* argv[])
return 1; return 1;
} }
break; break;
case SDL_MOUSEMOTION:
mousx = event.motion.x;
mousy = event.motion.y;
break;
case SDL_MOUSEBUTTONDOWN:
bstatus |= (1<<(event.button.button-1));
break;
case SDL_MOUSEBUTTONUP:
bstatus &= ~(1<<(event.button.button-1));
break;
case SDL_FINGERMOTION: case SDL_FINGERMOTION:
; ;
//printf("Finger: %i,x: %i, y: %i\n",event.tfinger.fingerId, #if VERBOSE
// event.tfinger.x,event.tfinger.y); printf("Finger: %i,x: %i, y: %i\n",event.tfinger.fingerId,
event.tfinger.x,event.tfinger.y);
#endif
SDL_Touch* inTouch = SDL_GetTouch(event.tfinger.touchId); SDL_Touch* inTouch = SDL_GetTouch(event.tfinger.touchId);
SDL_Finger* inFinger = SDL_GetFinger(inTouch,event.tfinger.fingerId); SDL_Finger* inFinger = SDL_GetFinger(inTouch,event.tfinger.fingerId);
/*
for(i = 0;i<MAXFINGERS;i++)
if(index2fingerid[i] == event.tfinger.fingerId)
break;
if(i == MAXFINGERS) break;
if(inTouch > 0) {
finger[i].p.x = ((float)event.tfinger.x)/
inTouch->xres;
finger[i].p.y = ((float)event.tfinger.y)/
inTouch->yres;
finger[i].pressure =
((float)event.tfinger.pressure)/inTouch->pressureres;
*/
/*
printf("Finger: %i, Pressure: %f Pressureres: %i\n",
event.tfinger.fingerId,
finger[i].pressure,
inTouch->pressureres);
*/
//printf("Finger: %i, pressure: %f\n",event.tfinger.fingerId,
// finger[event.tfinger.fingerId].pressure);
//}
break; break;
case SDL_FINGERDOWN: case SDL_FINGERDOWN:
//printf("Finger: %"PRIs64" down - x: %i, y: %i\n",event.tfinger.fingerId,event.tfinger.x,event.tfinger.y); #if VERBOSE
/* printf("Finger: %"PRIs64" down - x: %i, y: %i\n",
for(i = 0;i<MAXFINGERS;i++) event.tfinger.fingerId,event.tfinger.x,event.tfinger.y);
if(index2fingerid[i] == -1) { #endif
index2fingerid[i] = event.tfinger.fingerId;
break;
}
finger[i].p.x = event.tfinger.x;
finger[i].p.y = event.tfinger.y;
break; break;
case SDL_FINGERUP: case SDL_FINGERUP:
//printf("Finger: %"PRIs64" up - x: %i, y: %i\n",event.tfinger.fingerId,event.tfinger.x,event.tfinger.y); #if VERBOSE
for(i = 0;i<MAXFINGERS;i++) printf("Finger: %"PRIs64" up - x: %i, y: %i\n",
if(index2fingerid[i] == event.tfinger.fingerId) { event.tfinger.fingerId,event.tfinger.x,event.tfinger.y);
index2fingerid[i] = -1; #endif
break;
}
finger[i].p.x = -1;
finger[i].p.y = -1;
*/
break; break;
case SDL_MULTIGESTURE: case SDL_MULTIGESTURE:
/* #if VERBOSE
printf("Multi Gesture: x = %f, y = %f, dAng = %f, dR = %f\n", printf("Multi Gesture: x = %f, y = %f, dAng = %f, dR = %f\n",
event.mgesture.x, event.mgesture.x,
event.mgesture.y, event.mgesture.y,
event.mgesture.dTheta, event.mgesture.dTheta,
event.mgesture.dDist); event.mgesture.dDist);
printf("MG: numDownTouch = %i\n",event.mgesture.numFingers); printf("MG: numDownTouch = %i\n",event.mgesture.numFingers);
*/ #endif
knob.p.x = event.mgesture.x; knob.p.x = event.mgesture.x;
knob.p.y = event.mgesture.y; knob.p.y = event.mgesture.y;
knob.ang += event.mgesture.dTheta; knob.ang += event.mgesture.dTheta;
@ -437,13 +282,9 @@ int main(int argc, char* argv[])
break; break;
} }
} }
DrawScreen(screen,h); DrawScreen(screen);
//for(i = 0; i < 256; i++)
// if(keystat[i])
// printf("Key %i down\n",i);
} }
SDL_Quit(); SDL_Quit();
return 0; return 0;
} }