int main(int argc, char **argv)
{
IplImage *image_hsv = cvCreateImage(SIZE, 8, 3);
IplImage *image_h = cvCreateImage(SIZE, 8, 1);
IplImage *image_s = cvCreateImage(SIZE, 8, 1);
IplImage *image_v = cvCreateImage(SIZE, 8, 1);
cvNamedWindow("config", CV_WINDOW_AUTOSIZE);
//cvCreateTrackbar("threshold", "config", &thresh, 255, NULL);
while (cvWaitKey(10) < 0) {
IplImage *image = freenect_sync_get_rgb_cv(0);
if (!image) {
printf("Error: Kinect not connected?\n");
return -1;
}
cvCvtColor(image, image, CV_RGB2BGR);
cvCvtColor(image, image_hsv, CV_BGR2HSV);
cvSplit(image_hsv, image_h, image_s, image_v, NULL);
cvShowImage("RGB", image);
cvShowImage("HSV", image_hsv);
cvShowImage("H", image_h);
cvShowImage("S", image_s);
cvShowImage("V", image_v);
}
return 0;
}
int main(int argc, char **argv)
{
int thresh = 128;
int erode = 0;
int dilate = 0;
int do_contour = 0;
IplImage *image_bw = cvCreateImage(SIZE, 8, 1);
IplImage *image_thresh = cvCreateImage(SIZE, 8, 1);
IplImage *image_temp = cvCreateImage(SIZE, 8, 1);
cvNamedWindow("config", CV_WINDOW_AUTOSIZE);
cvCreateTrackbar("threshold", "config", &thresh, 255, NULL);
cvCreateTrackbar("erode", "config", &erode, 10, NULL);
cvCreateTrackbar("dilate", "config", &dilate, 10, NULL);
cvCreateTrackbar("contour", "config", &do_contour, 1, NULL);
CvMemStorage *storage = cvCreateMemStorage();
while (cvWaitKey(10) < 0) {
IplImage *image = freenect_sync_get_rgb_cv(0);
if (!image) {
printf("Error: Kinect not connected?\n");
return -1;
}
cvCvtColor(image, image, CV_RGB2BGR);
cvCvtColor(image, image_bw, CV_RGB2GRAY);
cvThreshold(image_bw, image_thresh, thresh, 255, CV_THRESH_BINARY);
cvErode(image_thresh, image_thresh, NULL, erode);
cvDilate(image_thresh, image_thresh, NULL, dilate);
if (do_contour) {
CvSeq *contours;
cvCopy(image_thresh, image_temp);
cvFindContours(image_temp, storage, &contours);
cvDrawContours(image, contours, CV_RGB(0, 255, 0), CV_RGB(0, 255, 255), 1);
}
cvShowImage("RGB", image);
cvShowImage("BW", image_bw);
cvShowImage("THRESH", image_thresh);
}
return 0;
}
int main(int argc, char **argv)
{
while (cvWaitKey(10) < 0) {
IplImage *image = freenect_sync_get_rgb_cv(0);
if (!image) {
printf("Error: Kinect not connected?\n");
return -1;
}
cvCvtColor(image, image, CV_RGB2BGR);
IplImage *depth = freenect_sync_get_depth_cv(0);
if (!depth) {
printf("Error: Kinect not connected?\n");
return -1;
}
cvShowImage("RGB", image);
cvShowImage("Depth", GlViewColor(depth));
}
}
int main (int argc, char *argv[])
{
IplImage *rgb, *depth, *tmp, *body, *hand;
CvMat **tr, *mean, *cov;
CvFileStorage *fs;
int count=0, p=0, warmup=1;
parse_args(argc, argv);
rgb = cvCreateImage(cvSize(W,H), 8, 3);
tr = (CvMat**)malloc(sizeof(CvMat*)*num);
init_training_data(tr,num);
mean = cvCreateMat(1, FD_NUM, CV_64FC1);
cov = cvCreateMat(FD_NUM, FD_NUM, CV_64FC1);
fs = cvOpenFileStorage(outfile, NULL, CV_STORAGE_WRITE, NULL);
assert(fs);
for (;;) {
int z, k, c;
CvMat *fd;
CvSeq *cnt;
tmp = freenect_sync_get_rgb_cv(0);
cvCvtColor(tmp, rgb, CV_BGR2RGB);
depth = freenect_sync_get_depth_cv(0);
body = body_detection(depth);
hand = hand_detection(body, &z);
if (!get_hand_contour_advanced(hand, rgb, z, &cnt, NULL))
continue;
if (warmup) {
draw_contour(cnt);
if (k = cvWaitKey(T) == 'g') {
warmup = 0;
cvDestroyAllWindows();
}
continue;
}
fd = get_fourier_descriptors(cnt);
add_training_data(tr[count], fd);
if (count == 0)
printf("---> training hand pose %d\n", p);
if (++count == num) {
int c;
cvCalcCovarMatrix((void*)tr, count, cov, mean, CV_COVAR_NORMAL);
cvInvert(cov, cov, CV_LU);
save_posture_model(fs, mean, cov);
p++;
count = 0;
printf("save and quit:s exit:q next:any \n");
if ((c = cvWaitKey(0)) == 's') {
break;
} else if (c == 'q') {
break;
} else {
continue;
}
}
draw_contour(cnt);
cvWaitKey(T);
}
cvWriteInt(fs, "total", p);
freenect_sync_stop();
free_training_data(tr,num);
cvReleaseFileStorage(&fs);
cvReleaseMat(&mean);
cvReleaseMat(&cov);
cvReleaseImage(&rgb);
return 0;
}
int main(int argc, char **argv)
{
int first = 1;
int angle = 0;
double duration = 5;
IplImage *image = 0;
IplImage *image2 = 0;
IplImage *prev = 0;
IplImage *output = 0;
IplImage *depth;
IplImage *diff = 0;
IplImage *bw = 0;
IplImage *edge = 0;
IplImage *edge2 = 0;
// if (!prev) prev = cvCreateImageHeader(cvSize(640,480), 8, 3);
//if (!diff) diff = cvCreateImageHeader(cvSize(640,480), 8, 3);
diff = cvCreateImage(cvSize(640,480),8,3);
bw = cvCreateImage(cvSize(640,480),8,1);
edge = cvCreateImage(cvSize(640,480),8,1);
edge2 = cvCreateImage(cvSize(640,480),8,1);
output = cvCreateImage(cvSize(640,480),8,3);
cvZero( output );
//cvCvtColor(output, output, CV_RGB2BGR);
while (1) {
switch(cvWaitKey(10)){
case 113:
exit(0);
case 'w':
angle++;
if(angle > 30)
angle = 30;
set_tilt_cv(angle,0);
break;
case 'x':
angle--;
if(angle < -30)
angle = -30;
set_tilt_cv(angle,0);
break;
case 's':
angle = 0;
set_tilt_cv(angle,0);
break;
case 'e':
angle += 10;
if(angle > 30)
angle = 30;
set_tilt_cv(angle,0);
break;
case 'c':
angle -=10;
if(angle < -30)
angle = -30;
set_tilt_cv(angle,0);
break;
default:
// cvWaitKey(700);
if(first){
prev = freenect_sync_get_rgb_cv(0);
//first = 0;
}
else
{
prev = cvCloneImage(image2);
cvReleaseImage(&image2);
}
image = freenect_sync_get_rgb_cv(0);
image2 = cvCloneImage(image);
if (!image) {
printf("Error: Kinect not connected?\n");
return -1;
}
cvCvtColor(image, image, CV_RGB2BGR);
// cvCvtColor(image2, image2, CV_RGB2BGR);
cvAbsDiff(image,prev,diff);
cvCvtColor(diff, bw,CV_BGR2GRAY);
cvCanny(bw, edge, 29000,30500,7);
// cvThreshold(bw,bw,100,254,CV_THRESH_BINARY);
cvNot(edge,edge2);
if(!first)
{
cvSubS(output,cvScalar(255,255,255,255),output,0);
cvAnd(GlViewColor(depth),GlViewColor(depth),output,edge);
//cvRunningAvg(GlViewColor(depth),output,1,edge);
}
//cvRunningAvg(image,output,1,edge);
if(!first)
{
cvReleaseImage(&prev);
}
else
first = 0;
cvAddWeighted(image, .3, output, .7, 1, image);
// OverlayImage(image2, output, cvPoint(0, 0), cvScalar(0.8,0.8,0.8,0.8), cvScalar(0.2,0.2,0.2,0.2));
/*
CvPoint* points[1];
CvPoint ptt[5];
points[0] = &(ptt[0]);
points[0][0] = cvPoint(100,100);
points[0][1] = cvPoint(200,100);
points[0][2] = cvPoint(150,150);
points[0][3] = cvPoint(150,300);
points[0][4] = cvPoint(100,250);
int npts[1];
npts[0]=5;
cvPolyLine(image, points, npts, 1,1, cvScalar(100,100,100,230),1, 8,0);
cvFillPoly(image, points, npts,1, cvScalar(100,100,100,230), 8,0);
*/
depth = freenect_sync_get_depth_cv(0);
cvSmooth(depth,depth,CV_BLUR,18,18,2.0,2.0);
if (!depth) {
printf("Error: Kinect not connected?\n");
return -1;
}
cvShowImage("RGB", image);
cvShowImage("Output", output);
cvShowImage("Depth", GlViewColor(depth));
break;
}
}
}
int main(int argc, char **argv)
{
cascade = (CvHaarClassifierCascade *) cvLoad("cascade.xml", 0, 0, 0);
IplImage *faceDepth = cvCreateImage(cvSize(100, 100), 8, 1);
char name[1000];
int imageCnt=0;
PCAWrapper pca;
if (!cascade)
{
fprintf(stderr, "ERROR: Could not load classifier cascade\n");
return -1;
}
storage = cvCreateMemStorage(0);
int key = -1;
while ((key & 0xFF) != 0x1B)
{ // Break when ESC is pressed.
key = cvWaitKey(10);
IplImage *image = freenect_sync_get_rgb_cv(0);
if (!image)
{
printf("Error: Kinect not connected?\n");
return -1;
}
// DEBUG;
/*
IplImage *irimage = freenect_sync_get_ir_cv(0); if (!irimage) {
printf("Error: Kinect not connected?\n"); return -1; } */
// DEBUG;
// cvCvtColor(image, image, CV_RGB2BGR);
IplImage *depth = freenect_sync_get_depth_cv(0);
if (!depth)
{
printf("Error: Kinect not connected?\n");
return -1;
}
// DEBUG;
// printf("%d\n", key);
if ((key & 0xFF) == 'p')
{
detect_and_draw(image, depth, faceDepth, true);
}
detect_and_draw(image, depth, faceDepth, false);
if ((key & 0xFF) == 'i')
{
imageCnt++;
sprintf(name, "face%d", imageCnt);
printf("face %s registered!\n", name);
pca.insertImage(faceDepth, name);
}
if((key & 0xFF) == 'r')
{
printf("%s Dist = %f\n", pca.search(faceDepth), pca.searchDist(faceDepth));
}
if((key & 0xFF) == 't')
{
printf("Training...\n");
pca.training();
}
cvShowImage("RGB", image);
// DEBUG;
// cvShowImage("IR", irimage);
cvShowImage("Depth", depth);
// cvShowImage("Depth", GlViewColor(depth));
}
return 0;
}
