File: XnDDK.cpp

package info (click to toggle)
openni-sensor-pointclouds 5.1.0.41.11-1
  • links: PTS, VCS
  • area: main
  • in suites: sid, trixie
  • size: 4,656 kB
  • sloc: cpp: 34,881; ansic: 14,901; sh: 249; python: 155; makefile: 93; xml: 8
file content (272 lines) | stat: -rw-r--r-- 8,493 bytes parent folder | download | duplicates (12)
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
/****************************************************************************
*                                                                           *
*  PrimeSense Sensor 5.x Alpha                                              *
*  Copyright (C) 2011 PrimeSense Ltd.                                       *
*                                                                           *
*  This file is part of PrimeSense Sensor.                                  *
*                                                                           *
*  PrimeSense Sensor is free software: you can redistribute it and/or modify*
*  it under the terms of the GNU Lesser General Public License as published *
*  by the Free Software Foundation, either version 3 of the License, or     *
*  (at your option) any later version.                                      *
*                                                                           *
*  PrimeSense Sensor is distributed in the hope that it will be useful,     *
*  but WITHOUT ANY WARRANTY; without even the implied warranty of           *
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the             *
*  GNU Lesser General Public License for more details.                      *
*                                                                           *
*  You should have received a copy of the GNU Lesser General Public License *
*  along with PrimeSense Sensor. If not, see <http://www.gnu.org/licenses/>.*
*                                                                           *
****************************************************************************/
//---------------------------------------------------------------------------
// Includes
//---------------------------------------------------------------------------
#include <XnDDK.h>
#include <XnFormats/XnFormats.h>
#include <XnOS.h>
#include "XnDeviceManager.h"
#include <XnUtils.h>

// The following line is needed to be once in *ALL* of the high level shared library modules. DO NOT REMOVE!!! 
XN_API_EXPORT_INIT()

//---------------------------------------------------------------------------
// Global Variables
//---------------------------------------------------------------------------
static XnBool g_XnDDKWasInit = FALSE;

//---------------------------------------------------------------------------
// Code
//---------------------------------------------------------------------------
XN_DDK_API XnStatus XnDDKInit(const XnChar* strDevicesDir)
{
	XnStatus nRetVal = XN_STATUS_OK;

	// Was the DDK subsystem already initialized?
	if (g_XnDDKWasInit == FALSE)
	{
		// Init the Formats library
		nRetVal = XnFormatsInit();
		if (nRetVal != XN_STATUS_OK && nRetVal != XN_STATUS_ALREADY_INIT)
			return nRetVal;

		// Init DeviceManager
		nRetVal = XnDeviceManagerInit(strDevicesDir);
		XN_IS_STATUS_OK(nRetVal);

		g_XnDDKWasInit = TRUE;
	}
	else
	{
		// Trying to init twice...
		return (XN_STATUS_DDK_ALREADY_INIT);
	}

	// All is good...
	return (XN_STATUS_OK);
}

XN_DDK_API XnStatus XnDDKInitFromINIFile(const XnChar* cpINIFileName)
{
	XnStatus nRetVal = XN_STATUS_OK;

	// Validate the input/output pointers (to make sure none of them is NULL)
	XN_VALIDATE_INPUT_PTR(cpINIFileName);

	// Was the DDK subsystem already initialized?
	if (g_XnDDKWasInit == FALSE)
	{
		// Init the Formats library
		nRetVal = XnFormatsInitFromINIFile(cpINIFileName);
		if (nRetVal != XN_STATUS_OK && nRetVal != XN_STATUS_ALREADY_INIT)
			return nRetVal;

		// read devices directory
		XnChar strDevicesDirectory[XN_INI_MAX_LEN] = "";
		XnChar* pDir = NULL;
		if (XN_STATUS_OK == xnOSReadStringFromINI(cpINIFileName, "DDK", "DevicesDir", strDevicesDirectory, XN_INI_MAX_LEN))
		{
			XN_VALIDATE_STR_APPEND(strDevicesDirectory, XN_FILE_DIR_SEP, XN_INI_MAX_LEN, nRetVal);
			pDir = strDevicesDirectory;
		}

		// Init DeviceManager
		nRetVal = XnDeviceManagerInit(pDir);
		if (nRetVal != XN_STATUS_OK && nRetVal != XN_STATUS_ALREADY_INIT)
			return nRetVal;

		g_XnDDKWasInit = TRUE;
	}
	else
	{
		// Trying to init twice...
		return (XN_STATUS_DDK_ALREADY_INIT);
	}

	// All is good...
	return (XN_STATUS_OK);
}

XN_DDK_API XnStatus XnDDKShutdown()
{
	// Local function variables
	XnStatus nRetVal = XN_STATUS_OK;

	// Was the DDK subsystem initialized?
	if (g_XnDDKWasInit == TRUE)
	{
		// shutdown device manager
		nRetVal = XnDeviceManagerShutdown();
		XN_IS_STATUS_OK(nRetVal);

		// shutdown the Formats library
		nRetVal = XnFormatsShutdown();
		if (nRetVal != XN_STATUS_OK && nRetVal != XN_STATUS_FORMATS_NOT_INIT)
			return nRetVal;

		g_XnDDKWasInit = FALSE;
	}
	else
	{
		// Trying to shutdown without doing init...
		return (XN_STATUS_DDK_NOT_INIT);
	}

	// All is good...
	return (XN_STATUS_OK);
}

XnResolution OldResToOpenNIRes(XnResolutions res)
{
	switch (res)
	{
	case XN_RESOLUTION_CUSTOM: return XN_RES_CUSTOM;
	case XN_RESOLUTION_QVGA: return XN_RES_QVGA;
	case XN_RESOLUTION_VGA: return XN_RES_VGA;
	case XN_RESOLUTION_SXGA: return XN_RES_SXGA;
	case XN_RESOLUTION_UXGA: return XN_RES_UXGA;
	case XN_RESOLUTION_QQVGA: return XN_RES_QQVGA;
	case XN_RESOLUTION_QCIF: return XN_RES_QCIF;
	case XN_RESOLUTION_240P: return XN_RES_240P;
	case XN_RESOLUTION_CIF: return XN_RES_CIF;
	case XN_RESOLUTION_WVGA: return XN_RES_WVGA;
	case XN_RESOLUTION_480P: return XN_RES_480P;
	case XN_RESOLUTION_800_448: return XN_RES_CUSTOM;
	case XN_RESOLUTION_SVGA: return XN_RES_SVGA;
	case XN_RESOLUTION_576P: return XN_RES_576P;
	case XN_RESOLUTION_DV: return XN_RES_DV;
	case XN_RESOLUTION_720P: return XN_RES_720P;
	case XN_RESOLUTION_1280_960: return XN_RES_CUSTOM;
	default: 
		XN_ASSERT(FALSE);
		return XN_RES_CUSTOM;
	}
}

XnResolutions OpenNIResToOldRes(XnResolution res)
{
	switch (res)
	{
	case XN_RES_CUSTOM: return XN_RESOLUTION_CUSTOM;
	case XN_RES_QQVGA: return XN_RESOLUTION_QQVGA;
	case XN_RES_CGA: return XN_RESOLUTION_CUSTOM;
	case XN_RES_QVGA: return XN_RESOLUTION_QVGA;
	case XN_RES_VGA: return XN_RESOLUTION_VGA;
	case XN_RES_SVGA: return XN_RESOLUTION_SVGA;
	case XN_RES_XGA: return XN_RESOLUTION_CUSTOM;
	case XN_RES_720P: return XN_RESOLUTION_720P;
	case XN_RES_SXGA: return XN_RESOLUTION_SXGA;
	case XN_RES_UXGA: return XN_RESOLUTION_UXGA;
	case XN_RES_1080P: return XN_RESOLUTION_CUSTOM;
	case XN_RES_QCIF: return XN_RESOLUTION_QCIF;
	case XN_RES_240P: return XN_RESOLUTION_240P;
	case XN_RES_CIF: return XN_RESOLUTION_CIF;
	case XN_RES_WVGA: return XN_RESOLUTION_WVGA;
	case XN_RES_480P: return XN_RESOLUTION_480P;
	case XN_RES_576P: return XN_RESOLUTION_576P;
	case XN_RES_DV: return XN_RESOLUTION_DV;
	default: 
		XN_ASSERT(FALSE);
		return XN_RESOLUTION_CUSTOM;
	}
}

XN_DDK_API XnResolutions XnDDKGetResolutionFromXY(XnUInt32 nXRes, XnUInt32 nYRes)
{
	// check if this is a known OpenNI resolution
	XnResolution res = xnResolutionGetFromXYRes(nXRes, nYRes);
	if (res == XN_RES_CUSTOM)
	{
		// check if this is one of our special resolutions
		if (nXRes == 800 && nYRes == 448)
		{
			return XN_RESOLUTION_800_448;
		}
		else if (nXRes == 1280 && nYRes == 960)
		{
			return XN_RESOLUTION_1280_960;
		}
	}

	return OpenNIResToOldRes(res);
}

XN_DDK_API XnBool XnDDKGetXYFromResolution(XnResolutions res, XnUInt32* pnXRes, XnUInt32* pnYRes)
{
	// check if this is a known OpenNI resolution
	XnResolution openRes = OldResToOpenNIRes(res);
	if (openRes == XN_RES_CUSTOM)
	{
		// check if this is one of our special resolutions
		if (res == XN_RESOLUTION_800_448)
		{
			*pnXRes = 800; 
			*pnYRes = 448; 
			return TRUE;
		}
		else if (res == XN_RESOLUTION_1280_960)
		{
			*pnXRes = 1280;
			*pnYRes = 960;
			return TRUE;
		}
		else
		{
			return FALSE;
		}
	}
	else
	{
		*pnXRes = xnResolutionGetXRes(openRes);
		*pnYRes = xnResolutionGetYRes(openRes);
		return TRUE;
	}
}

XN_DDK_API const XnChar* XnDDKGetResolutionName(XnResolutions res)
{
	// check if this is a known OpenNI resolution
	XnResolution openRes = OldResToOpenNIRes(res);

	if (openRes == XN_RES_CUSTOM)
	{
		// check if this is one of our special resolutions
		if (res == XN_RESOLUTION_800_448)
		{
			return "800x448";
		}
		else if (res == XN_RESOLUTION_1280_960)
		{
			return "1280x960";
		}
		else
		{
			return "Custom";
		}
	}
	else
	{
		return xnResolutionGetName(openRes);
	}
}