MicrosoftKinect/test_main.cpp at master · yudonguk/MicrosoftKinect · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
#ifdef TEST_BUILD

#include <iostream>
#include <device/Property.h>
#include <device/OprosMath.h>

#include <opencv/cv.h>
#include <opencv/highgui.h>

#include "MicroSoftKinect.h"
#include "debug_macro.h"

OPRoS::Property GetProperty()
{
	OPRoS::Property property;

	property.SetValue("ColorWidth", "640");
	property.SetValue("ColorHeight", "480");
	property.SetValue("DepthWidth", "640");
	property.SetValue("DepthHeight", "480");

	property.SetValue("KinectIndex", "0");
	property.SetValue("NearMode", "true");
	property.SetValue("SkeletonTrackingMode", "false");

	return property;
}


int main()
{
	MicrosoftKinect kinect;

	if (kinect.Initialize(GetProperty()) != API_SUCCESS)
	{
		std::cerr << DEBUG_MESSAGE("Can't initialize MicrosoftKinect");
		kinect.Finalize();
		return 0;
	}

	if (kinect.Enable() != API_SUCCESS )
	{
		std::cerr << DEBUG_MESSAGE("Can't initialize MicrosoftKinect");
		kinect.Finalize();
		return 0;
	}

	kinect.SetCameraAngle(20);
	kinect.SetCameraAngle(-20);
	kinect.SetCameraAngle(0);

	ImageFrame imageFrame;
	DepthFrame depthFrame;
	std::vector<Skeleton> skeletons;

	while(kinect.GetImage(imageFrame) != API_SUCCESS || kinect.GetDepthImage(depthFrame) != API_SUCCESS)
	{
		if (cvWaitKey(10) == VK_ESCAPE)
		{
			kinect.Finalize();
			return 0;
		}
	}

	IplImage* pImage = cvCreateImage(cvSize(imageFrame.width, imageFrame.height), 8, 3);
	IplImage* pDepthImage = cvCreateImage(cvSize(depthFrame.width, depthFrame.height), 8, 1);
	IplImage* pDepthImageHeader = cvCreateImageHeader(cvSize(depthFrame.width, depthFrame.height), 16, 1);

	for (; cvWaitKey(10) != VK_ESCAPE;)
	{
		if (kinect.GetImage(imageFrame) != API_SUCCESS || kinect.GetDepthImage(depthFrame) != API_SUCCESS)
			continue;
		kinect.GetSkeleton(skeletons);

		memcpy(pImage->imageData, &(*imageFrame.data)[0], pImage->imageSize);

		if(skeletons.size() != 0)
		{
			for(size_t i = 0; i < skeletons.size(); i++)
			{
				Skeleton& skeleton = skeletons[i];
				char* resultMessage = "";
				CvScalar color = CV_RGB(255, skeleton.userID * 2, (skeleton.userID >> 8) * 2);

				switch(skeleton.result)
				{
				case Skeleton::NOT_TRACKED:
					resultMessage = "Not Tracked";
					break;
				case Skeleton::POSITION_ONLY:
					cvCircle(pImage, cvPoint((int)skeleton.position.x, (int)skeleton.position.y), 5, color, 1);
					resultMessage = "Position Only";
					break;
				case Skeleton::TRACKED:
					for(int index = 0; index < skeleton.JOINT_COUNT; index++)
					{
						cvCircle(pImage, cvPoint((int)skeleton.joints[index].x
							, (int)skeleton.joints[index].y), 5, color);
					}
					resultMessage = "Tracked";
					break;
				default:
					resultMessage = "Unknown";
					break;
				}

				std::cout << skeleton.userID << " : " << resultMessage << std::endl;
			}
		}

		pDepthImageHeader->imageData = (char*)&(*depthFrame.data)[0];

		cvNormalize(pDepthImageHeader, pDepthImage, 0, 0xFF, CV_MINMAX);

		cvShowImage("Kinect RGB", pImage);
		cvShowImage("Kinect Depth", pDepthImage);
	}

	cvReleaseImage(&pImage);
	cvReleaseImage(&pDepthImage);
	cvReleaseImageHeader(&pDepthImageHeader);

	kinect.Finalize();

	return 0;
}

#endif