00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #ifndef __XN_CPP_WRAPPER_H__
00023 #define __XN_CPP_WRAPPER_H__
00024
00025
00026
00027
00028 #include <XnOpenNI.h>
00029 #include <XnCodecIDs.h>
00030
00031
00032
00033
00034 namespace xn
00035 {
00036
00037
00038
00039 class ProductionNode;
00040 class EnumerationErrors;
00041 class NodeInfo;
00042 class NodeInfoList;
00043 class Context;
00044 class Query;
00045 class Generator;
00046
00052
00053
00054
00055
00062 typedef void (XN_CALLBACK_TYPE* StateChangedHandler)(ProductionNode& node, void* pCookie);
00063
00064
00065
00066
00067 typedef XnStatus (*_XnRegisterStateChangeFuncPtr)(XnNodeHandle hNode, XnStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback);
00068 typedef void (*_XnUnregisterStateChangeFuncPtr)(XnNodeHandle hNode, XnCallbackHandle hCallback);
00069
00070 static XnStatus _RegisterToStateChange(_XnRegisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode, StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback);
00071 static void _UnregisterFromStateChange(_XnUnregisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode, XnCallbackHandle hCallback);
00072
00073
00074
00075
00076 class Version
00077 {
00078 public:
00079 Version(const XnVersion& version) : m_version(version) {}
00080 Version(XnUInt8 nMajor, XnUInt8 nMinor, XnUInt16 nMaintenance, XnUInt32 nBuild)
00081 {
00082 m_version.nMajor = nMajor;
00083 m_version.nMinor = nMinor;
00084 m_version.nMaintenance = nMaintenance;
00085 m_version.nBuild = nBuild;
00086 }
00087
00088 bool operator==(const Version& other) const
00089 {
00090 return (xnVersionCompare(&m_version, &other.m_version) == 0);
00091 }
00092 bool operator!=(const Version& other) const
00093 {
00094 return (xnVersionCompare(&m_version, &other.m_version) != 0);
00095 }
00096 bool operator<(const Version& other) const
00097 {
00098 return (xnVersionCompare(&m_version, &other.m_version) < 0);
00099 }
00100 bool operator<=(const Version& other) const
00101 {
00102 return (xnVersionCompare(&m_version, &other.m_version) <= 0);
00103 }
00104 bool operator>(const Version& other) const
00105 {
00106 return (xnVersionCompare(&m_version, &other.m_version) > 0);
00107 }
00108 bool operator>=(const Version& other) const
00109 {
00110 return (xnVersionCompare(&m_version, &other.m_version) >= 0);
00111 }
00112 private:
00113 XnVersion m_version;
00114 };
00115
00116
00117
00118
00119
00124 class OutputMetaData
00125 {
00126 public:
00132 inline OutputMetaData(const XnUInt8** ppData) : m_pAllocatedData(NULL), m_ppData(ppData), m_nAllocatedSize(0)
00133 {
00134 xnOSMemSet(&m_output, 0, sizeof(XnOutputMetaData));
00135 }
00136
00140 virtual ~OutputMetaData() { Free(); }
00141
00143 inline XnUInt64 Timestamp() const { return m_output.nTimestamp; }
00145 inline XnUInt64& Timestamp() { return m_output.nTimestamp; }
00146
00148 inline XnUInt32 FrameID() const { return m_output.nFrameID; }
00150 inline XnUInt32& FrameID() { return m_output.nFrameID; }
00151
00153 inline XnUInt32 DataSize() const { return m_output.nDataSize; }
00155 inline XnUInt32& DataSize() { return m_output.nDataSize; }
00156
00158 inline XnBool IsDataNew() const { return m_output.bIsNew; }
00160 inline XnBool& IsDataNew() { return m_output.bIsNew; }
00161
00163 inline const XnOutputMetaData* GetUnderlying() const { return &m_output; }
00165 inline XnOutputMetaData* GetUnderlying() { return &m_output; }
00166
00168 inline const XnUInt8* Data() const { return *m_ppData; }
00170 inline const XnUInt8*& Data() { return *m_ppData; }
00172 inline XnUInt8* WritableData()
00173 {
00174 MakeDataWritable();
00175 return m_pAllocatedData;
00176 }
00177
00184 XnStatus AllocateData(XnUInt32 nBytes)
00185 {
00186 if (nBytes > m_nAllocatedSize)
00187 {
00188
00189 XnUInt8* pData = (XnUInt8*)xnOSMallocAligned(nBytes, XN_DEFAULT_MEM_ALIGN);
00190 XN_VALIDATE_ALLOC_PTR(pData);
00191
00192
00193 Free();
00194 m_pAllocatedData = pData;
00195 m_nAllocatedSize = nBytes;
00196 }
00197
00198 DataSize() = nBytes;
00199 *m_ppData = m_pAllocatedData;
00200
00201 return XN_STATUS_OK;
00202 }
00203
00207 void Free()
00208 {
00209 if (m_nAllocatedSize != 0)
00210 {
00211 xnOSFreeAligned(m_pAllocatedData);
00212 m_pAllocatedData = NULL;
00213 m_nAllocatedSize = 0;
00214 }
00215 }
00216
00221 XnStatus MakeDataWritable()
00222 {
00223 XnStatus nRetVal = XN_STATUS_OK;
00224
00225
00226 if (Data() != m_pAllocatedData || DataSize() > m_nAllocatedSize)
00227 {
00228 const XnUInt8* pOrigData = *m_ppData;
00229
00230 nRetVal = AllocateData(DataSize());
00231 XN_IS_STATUS_OK(nRetVal);
00232
00233 if (pOrigData != NULL)
00234 {
00235 xnOSMemCopy(m_pAllocatedData, pOrigData, DataSize());
00236 }
00237 else
00238 {
00239 xnOSMemSet(m_pAllocatedData, 0, DataSize());
00240 }
00241 }
00242
00243 return (XN_STATUS_OK);
00244 }
00245
00246 protected:
00247 XnUInt8* m_pAllocatedData;
00248
00249 private:
00250 XnOutputMetaData m_output;
00251
00252 const XnUInt8** m_ppData;
00253 XnUInt32 m_nAllocatedSize;
00254 };
00255
00260 class MapMetaData : public OutputMetaData
00261 {
00262 public:
00269 inline MapMetaData(XnPixelFormat format, const XnUInt8** ppData) : OutputMetaData(ppData)
00270 {
00271 xnOSMemSet(&m_map, 0, sizeof(XnMapMetaData));
00272 m_map.pOutput = OutputMetaData::GetUnderlying();
00273 m_map.PixelFormat = format;
00274 }
00275
00277 inline XnUInt32 XRes() const { return m_map.Res.X; }
00279 inline XnUInt32& XRes() { return m_map.Res.X; }
00280
00282 inline XnUInt32 YRes() const { return m_map.Res.Y; }
00284 inline XnUInt32& YRes() { return m_map.Res.Y; }
00285
00287 inline XnUInt32 XOffset() const { return m_map.Offset.X; }
00289 inline XnUInt32& XOffset() { return m_map.Offset.X; }
00290
00292 inline XnUInt32 YOffset() const { return m_map.Offset.Y; }
00294 inline XnUInt32& YOffset() { return m_map.Offset.Y; }
00295
00297 inline XnUInt32 FullXRes() const { return m_map.FullRes.X; }
00299 inline XnUInt32& FullXRes() { return m_map.FullRes.X; }
00300
00302 inline XnUInt32 FullYRes() const { return m_map.FullRes.Y; }
00304 inline XnUInt32& FullYRes() { return m_map.FullRes.Y; }
00305
00307 inline XnUInt32 FPS() const { return m_map.nFPS; }
00309 inline XnUInt32& FPS() { return m_map.nFPS; }
00310
00312 inline XnPixelFormat PixelFormat() const { return m_map.PixelFormat; }
00313
00315 inline const XnMapMetaData* GetUnderlying() const { return &m_map; }
00317 inline XnMapMetaData* GetUnderlying() { return &m_map; }
00318
00320 inline XnUInt32 BytesPerPixel() const
00321 {
00322 switch (PixelFormat())
00323 {
00324 case XN_PIXEL_FORMAT_RGB24:
00325 return sizeof(XnRGB24Pixel);
00326 case XN_PIXEL_FORMAT_YUV422:
00327 return sizeof(XnYUV422DoublePixel)/2;
00328 case XN_PIXEL_FORMAT_GRAYSCALE_8_BIT:
00329 return sizeof(XnGrayscale8Pixel);
00330 case XN_PIXEL_FORMAT_GRAYSCALE_16_BIT:
00331 return sizeof(XnGrayscale16Pixel);
00332 case XN_PIXEL_FORMAT_MJPEG:
00333 return 2;
00334 default:
00335 XN_ASSERT(FALSE);
00336 return 0;
00337 }
00338 }
00339
00346 XnStatus AllocateData(XnUInt32 nXRes, XnUInt32 nYRes)
00347 {
00348 XnStatus nRetVal = XN_STATUS_OK;
00349
00350 XnUInt32 nSize = nXRes * nYRes * BytesPerPixel();
00351 nRetVal = OutputMetaData::AllocateData(nSize);
00352 XN_IS_STATUS_OK(nRetVal);
00353
00354 FullXRes() = XRes() = nXRes;
00355 FullYRes() = YRes() = nYRes;
00356 XOffset() = YOffset() = 0;
00357
00358 return (XN_STATUS_OK);
00359 }
00360
00369 XnStatus ReAdjust(XnUInt32 nXRes, XnUInt32 nYRes, const XnUInt8* pExternalBuffer)
00370 {
00371 XnStatus nRetVal = XN_STATUS_OK;
00372
00373 if (pExternalBuffer == NULL)
00374 {
00375 nRetVal = AllocateData(nXRes, nYRes);
00376 XN_IS_STATUS_OK(nRetVal);
00377 }
00378 else
00379 {
00380 FullXRes() = XRes() = nXRes;
00381 FullYRes() = YRes() = nYRes;
00382 XOffset() = YOffset() = 0;
00383 Data() = pExternalBuffer;
00384 DataSize() = nXRes * nYRes * BytesPerPixel();
00385 }
00386
00387 return (XN_STATUS_OK);
00388 }
00389
00390 protected:
00391 XnPixelFormat& PixelFormatImpl() { return m_map.PixelFormat; }
00392
00393 private:
00394
00395 MapMetaData& operator=(const MapMetaData&);
00396 inline MapMetaData(const MapMetaData& other);
00397
00398
00399 XnMapMetaData m_map;
00400 };
00401
00402
00403 #define _XN_DECLARE_MAP_DATA_CLASS(_name, _pixelType) \
00404 class _name \
00405 { \
00406 public: \
00407 inline _name(_pixelType*& pData, XnUInt32& nXRes, XnUInt32 &nYRes) : \
00408 m_pData(pData), m_nXRes(nXRes), m_nYRes(nYRes) {} \
00409 \
00410 inline XnUInt32 XRes() const { return m_nXRes; } \
00411 inline XnUInt32 YRes() const { return m_nYRes; } \
00412 \
00413 inline const _pixelType& operator[](XnUInt32 nIndex) const \
00414 { \
00415 XN_ASSERT(nIndex < (m_nXRes * m_nYRes)); \
00416 return m_pData[nIndex]; \
00417 } \
00418 inline _pixelType& operator[](XnUInt32 nIndex) \
00419 { \
00420 XN_ASSERT(nIndex < (m_nXRes *m_nYRes)); \
00421 return m_pData[nIndex]; \
00422 } \
00423 \
00424 inline const _pixelType& operator()(XnUInt32 x, XnUInt32 y) const \
00425 { \
00426 XN_ASSERT(x < m_nXRes && y < m_nYRes); \
00427 return m_pData[y*m_nXRes + x]; \
00428 } \
00429 inline _pixelType& operator()(XnUInt32 x, XnUInt32 y) \
00430 { \
00431 XN_ASSERT(x < m_nXRes && y < m_nYRes); \
00432 return m_pData[y*m_nXRes + x]; \
00433 } \
00434 \
00435 private: \
00436 \
00437 _name(const _name& other); \
00438 _name& operator=(const _name&); \
00439 \
00440 _pixelType*& m_pData; \
00441 XnUInt32& m_nXRes; \
00442 XnUInt32& m_nYRes; \
00443 };
00444
00445 _XN_DECLARE_MAP_DATA_CLASS(DepthMap, XnDepthPixel);
00446 _XN_DECLARE_MAP_DATA_CLASS(ImageMap, XnUInt8);
00447 _XN_DECLARE_MAP_DATA_CLASS(RGB24Map, XnRGB24Pixel);
00448 _XN_DECLARE_MAP_DATA_CLASS(Grayscale16Map, XnGrayscale16Pixel);
00449 _XN_DECLARE_MAP_DATA_CLASS(Grayscale8Map, XnGrayscale8Pixel);
00450 _XN_DECLARE_MAP_DATA_CLASS(IRMap, XnIRPixel);
00451 _XN_DECLARE_MAP_DATA_CLASS(LabelMap, XnLabel);
00452
00457 class DepthMetaData : public MapMetaData
00458 {
00459 public:
00463 inline DepthMetaData() :
00464 MapMetaData(XN_PIXEL_FORMAT_GRAYSCALE_16_BIT, (const XnUInt8**)&m_depth.pData),
00465 m_depthMap(const_cast<XnDepthPixel*&>(m_depth.pData), MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y),
00466 m_writableDepthMap((XnDepthPixel*&)m_pAllocatedData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y)
00467 {
00468 xnOSMemSet(&m_depth, 0, sizeof(XnDepthMetaData));
00469 m_depth.pMap = MapMetaData::GetUnderlying();
00470 }
00471
00477 inline void InitFrom(const DepthMetaData& other)
00478 {
00479 xnCopyDepthMetaData(&m_depth, &other.m_depth);
00480 }
00481
00491 inline XnStatus InitFrom(const DepthMetaData& other, XnUInt32 nXRes, XnUInt32 nYRes, const XnDepthPixel* pExternalBuffer)
00492 {
00493 InitFrom(other);
00494 return ReAdjust(nXRes, nYRes, pExternalBuffer);
00495 }
00496
00502 XnStatus CopyFrom(const DepthMetaData& other)
00503 {
00504
00505 InitFrom(other);
00506
00507 return MakeDataWritable();
00508 }
00509
00511 XnStatus ReAdjust(XnUInt32 nXRes, XnUInt32 nYRes, const XnDepthPixel* pExternalBuffer = NULL)
00512 {
00513 return MapMetaData::ReAdjust(nXRes, nYRes, (const XnUInt8*)pExternalBuffer);
00514 }
00515
00517 inline XnDepthPixel ZRes() const { return m_depth.nZRes; }
00519 inline XnDepthPixel& ZRes() { return m_depth.nZRes; }
00520
00522 inline const XnDepthPixel* Data() const { return (const XnDepthPixel*)MapMetaData::Data(); }
00524 inline const XnDepthPixel*& Data() { return (const XnDepthPixel*&)MapMetaData::Data(); }
00526 inline XnDepthPixel* WritableData() { return (XnDepthPixel*)MapMetaData::WritableData(); }
00527
00529 inline const xn::DepthMap& DepthMap() const { return m_depthMap; }
00531 inline xn::DepthMap& WritableDepthMap()
00532 {
00533 MakeDataWritable();
00534 return m_writableDepthMap;
00535 }
00536
00542 inline const XnDepthPixel& operator[](XnUInt32 nIndex) const
00543 {
00544 XN_ASSERT(nIndex < (XRes()*YRes()));
00545 return Data()[nIndex];
00546 }
00547
00554 inline const XnDepthPixel& operator()(XnUInt32 x, XnUInt32 y) const
00555 {
00556 XN_ASSERT(x < XRes() && y < YRes());
00557 return Data()[y*XRes() + x];
00558 }
00559
00561 inline const XnDepthMetaData* GetUnderlying() const { return &m_depth; }
00563 inline XnDepthMetaData* GetUnderlying() { return &m_depth; }
00564
00565 private:
00566
00567 DepthMetaData(const DepthMetaData& other);
00568 DepthMetaData& operator=(const DepthMetaData&);
00569
00570 XnDepthMetaData m_depth;
00571 const xn::DepthMap m_depthMap;
00572 xn::DepthMap m_writableDepthMap;
00573 };
00574
00579 class ImageMetaData : public MapMetaData
00580 {
00581 public:
00583 inline ImageMetaData() :
00584 MapMetaData(XN_PIXEL_FORMAT_RGB24, &m_image.pData),
00585 m_imageMap(const_cast<XnUInt8*&>(m_image.pData), MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y),
00586 m_writableImageMap((XnUInt8*&)m_pAllocatedData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y),
00587 m_rgb24Map((XnRGB24Pixel*&)m_image.pData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y),
00588 m_writableRgb24Map((XnRGB24Pixel*&)m_pAllocatedData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y),
00589 m_gray16Map((XnGrayscale16Pixel*&)m_image.pData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y),
00590 m_writableGray16Map((XnGrayscale16Pixel*&)m_pAllocatedData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y),
00591 m_gray8Map((XnGrayscale8Pixel*&)m_image.pData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y),
00592 m_writableGray8Map((XnGrayscale8Pixel*&)m_pAllocatedData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y)
00593 {
00594 xnOSMemSet(&m_image, 0, sizeof(XnImageMetaData));
00595 m_image.pMap = MapMetaData::GetUnderlying();
00596 }
00597
00603 inline void InitFrom(const ImageMetaData& other)
00604 {
00605 xnCopyImageMetaData(&m_image, &other.m_image);
00606 }
00607
00618 inline XnStatus InitFrom(const ImageMetaData& other, XnUInt32 nXRes, XnUInt32 nYRes, XnPixelFormat format, const XnUInt8* pExternalBuffer)
00619 {
00620 InitFrom(other);
00621 XnStatus nRetVal = ReAdjust(nXRes, nYRes, format, pExternalBuffer);
00622 XN_IS_STATUS_OK(nRetVal);
00623 PixelFormat() = format;
00624 return XN_STATUS_OK;
00625 }
00626
00634 inline XnStatus AllocateData(XnUInt32 nXRes, XnUInt32 nYRes, XnPixelFormat format)
00635 {
00636 XnPixelFormat origFormat = PixelFormat();
00637 PixelFormat() = format;
00638 XnStatus nRetVal = MapMetaData::AllocateData(nXRes, nYRes);
00639 if (nRetVal != XN_STATUS_OK)
00640 {
00641 PixelFormat() = origFormat;
00642 return (nRetVal);
00643 }
00644
00645 return XN_STATUS_OK;
00646 }
00647
00649 inline XnStatus CopyFrom(const ImageMetaData& other)
00650 {
00651
00652 xnCopyImageMetaData(&m_image, &other.m_image);
00653
00654 return MakeDataWritable();
00655 }
00656
00666 XnStatus ReAdjust(XnUInt32 nXRes, XnUInt32 nYRes, XnPixelFormat format, const XnUInt8* pExternalBuffer = NULL)
00667 {
00668 XnPixelFormat origFormat = PixelFormat();
00669 PixelFormat() = format;
00670 XnStatus nRetVal = MapMetaData::ReAdjust(nXRes, nYRes, pExternalBuffer);
00671 if (nRetVal != XN_STATUS_OK)
00672 {
00673 PixelFormat() = origFormat;
00674 return (nRetVal);
00675 }
00676
00677 return XN_STATUS_OK;
00678 }
00679
00681 inline XnPixelFormat PixelFormat() const { return MapMetaData::PixelFormat(); }
00683 inline XnPixelFormat& PixelFormat() { return MapMetaData::PixelFormatImpl(); }
00684
00686 inline XnUInt8* WritableData() { return MapMetaData::WritableData(); }
00687
00689 inline const XnRGB24Pixel* RGB24Data() const { return (const XnRGB24Pixel*)MapMetaData::Data(); }
00691 inline const XnRGB24Pixel*& RGB24Data() { return (const XnRGB24Pixel*&)MapMetaData::Data(); }
00693 inline XnRGB24Pixel* WritableRGB24Data() { return (XnRGB24Pixel*)MapMetaData::WritableData(); }
00694
00696 inline const XnYUV422DoublePixel* YUV422Data() const { return (const XnYUV422DoublePixel*)MapMetaData::Data(); }
00698 inline const XnYUV422DoublePixel*& YUV422Data() { return (const XnYUV422DoublePixel*&)MapMetaData::Data(); }
00700 inline XnYUV422DoublePixel* WritableYUV422Data() { return (XnYUV422DoublePixel*)MapMetaData::WritableData(); }
00701
00703 inline const XnGrayscale8Pixel* Grayscale8Data() const { return (const XnGrayscale8Pixel*)MapMetaData::Data(); }
00705 inline const XnGrayscale8Pixel*& Grayscale8Data() { return (const XnGrayscale8Pixel*&)MapMetaData::Data(); }
00707 inline XnGrayscale8Pixel* WritableGrayscale8Data() { return (XnGrayscale8Pixel*)MapMetaData::WritableData(); }
00708
00710 inline const XnGrayscale16Pixel* Grayscale16Data() const { return (const XnGrayscale16Pixel*)MapMetaData::Data(); }
00712 inline const XnGrayscale16Pixel*& Grayscale16Data() { return (const XnGrayscale16Pixel*&)MapMetaData::Data(); }
00714 inline XnGrayscale16Pixel* WritableGrayscale16Data() { return (XnGrayscale16Pixel*)MapMetaData::WritableData(); }
00715
00717 inline const xn::ImageMap& ImageMap() const { return m_imageMap; }
00719 inline xn::ImageMap& WritableImageMap() { MakeDataWritable(); return m_writableImageMap; }
00720
00722 inline const xn::RGB24Map& RGB24Map() const { return m_rgb24Map; }
00724 inline xn::RGB24Map& WritableRGB24Map() { MakeDataWritable(); return m_writableRgb24Map; }
00725
00727 inline const xn::Grayscale8Map& Grayscale8Map() const { return m_gray8Map; }
00729 inline xn::Grayscale8Map& WritableGrayscale8Map() { MakeDataWritable(); return m_writableGray8Map; }
00730
00732 inline const xn::Grayscale16Map& Grayscale16Map() const { return m_gray16Map; }
00734 inline xn::Grayscale16Map& WritableGrayscale16Map() { MakeDataWritable(); return m_writableGray16Map; }
00735
00737 inline const XnImageMetaData* GetUnderlying() const { return &m_image; }
00739 inline XnImageMetaData* GetUnderlying() { return &m_image; }
00740
00741 private:
00742
00743 ImageMetaData(const ImageMetaData& other);
00744 ImageMetaData& operator=(const ImageMetaData&);
00745
00746 XnImageMetaData m_image;
00747 const xn::ImageMap m_imageMap;
00748 xn::ImageMap m_writableImageMap;
00749 const xn::RGB24Map m_rgb24Map;
00750 xn::RGB24Map m_writableRgb24Map;
00751 const xn::Grayscale16Map m_gray16Map;
00752 xn::Grayscale16Map m_writableGray16Map;
00753 const xn::Grayscale8Map m_gray8Map;
00754 xn::Grayscale8Map m_writableGray8Map;
00755 };
00756
00761 class IRMetaData : public MapMetaData
00762 {
00763 public:
00765 inline IRMetaData() :
00766 MapMetaData(XN_PIXEL_FORMAT_GRAYSCALE_16_BIT, (const XnUInt8**)&m_ir.pData),
00767 m_irMap(const_cast<XnIRPixel*&>(m_ir.pData), MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y),
00768 m_writableIRMap((XnIRPixel*&)m_pAllocatedData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y)
00769 {
00770 xnOSMemSet(&m_ir, 0, sizeof(XnIRMetaData));
00771 m_ir.pMap = MapMetaData::GetUnderlying();
00772 }
00773
00779 inline void InitFrom(const IRMetaData& other)
00780 {
00781 xnCopyIRMetaData(&m_ir, &other.m_ir);
00782 }
00783
00785 inline XnStatus InitFrom(const IRMetaData& other, XnUInt32 nXRes, XnUInt32 nYRes, const XnIRPixel* pExternalBuffer)
00786 {
00787 InitFrom(other);
00788 return ReAdjust(nXRes, nYRes, pExternalBuffer);
00789 }
00790
00792 XnStatus CopyFrom(const IRMetaData& other)
00793 {
00794
00795 xnCopyIRMetaData(&m_ir, &other.m_ir);
00796
00797 return MakeDataWritable();
00798 }
00799
00801 XnStatus ReAdjust(XnUInt32 nXRes, XnUInt32 nYRes, const XnIRPixel* pExternalBuffer = NULL)
00802 {
00803 return MapMetaData::ReAdjust(nXRes, nYRes, (const XnUInt8*)pExternalBuffer);
00804 }
00805
00807 inline const XnIRPixel* Data() const { return (const XnIRPixel*)MapMetaData::Data(); }
00809 inline const XnIRPixel*& Data() { return (const XnIRPixel*&)MapMetaData::Data(); }
00811 inline XnIRPixel* WritableData() { return (XnIRPixel*)MapMetaData::WritableData(); }
00812
00814 inline const xn::IRMap& IRMap() const { return m_irMap; }
00816 inline xn::IRMap& WritableIRMap() { MakeDataWritable(); return m_writableIRMap; }
00817
00819 inline const XnIRMetaData* GetUnderlying() const { return &m_ir; }
00821 inline XnIRMetaData* GetUnderlying() { return &m_ir; }
00822
00823 private:
00824
00825 IRMetaData(const IRMetaData& other);
00826 IRMetaData& operator=(const IRMetaData&);
00827
00828 XnIRMetaData m_ir;
00829 const xn::IRMap m_irMap;
00830 xn::IRMap m_writableIRMap;
00831 };
00832
00837 class AudioMetaData : public OutputMetaData
00838 {
00839 public:
00841 inline AudioMetaData() : OutputMetaData(&m_audio.pData)
00842 {
00843 xnOSMemSet(&m_audio, 0, sizeof(XnAudioMetaData));
00844 m_audio.pOutput = OutputMetaData::GetUnderlying();
00845 }
00846
00852 inline void InitFrom(const AudioMetaData& other)
00853 {
00854 xnCopyAudioMetaData(&m_audio, &other.m_audio);
00855 }
00856
00858 inline XnUInt8 NumberOfChannels() const { return m_audio.Wave.nChannels; }
00860 inline XnUInt8& NumberOfChannels() { return m_audio.Wave.nChannels; }
00861
00863 inline XnUInt32 SampleRate() const { return m_audio.Wave.nSampleRate; }
00865 inline XnUInt32& SampleRate() { return m_audio.Wave.nSampleRate; }
00866
00868 inline XnUInt16 BitsPerSample() const { return m_audio.Wave.nBitsPerSample; }
00870 inline XnUInt16& BitsPerSample() { return m_audio.Wave.nBitsPerSample; }
00871
00873 inline const XnAudioMetaData* GetUnderlying() const { return &m_audio; }
00875 inline XnAudioMetaData* GetUnderlying() { return &m_audio; }
00876
00877 private:
00878
00879 AudioMetaData(const AudioMetaData& other);
00880 AudioMetaData& operator=(const AudioMetaData&);
00881
00882 XnAudioMetaData m_audio;
00883 XnBool m_bAllocated;
00884 };
00885
00890 class SceneMetaData : public MapMetaData
00891 {
00892 public:
00894 inline SceneMetaData() :
00895 MapMetaData(XN_PIXEL_FORMAT_GRAYSCALE_16_BIT, (const XnUInt8**)&m_scene.pData),
00896 m_labelMap(const_cast<XnLabel*&>(m_scene.pData), MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y),
00897 m_writableLabelMap((XnLabel*&)m_pAllocatedData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y)
00898 {
00899 xnOSMemSet(&m_scene, 0, sizeof(XnSceneMetaData));
00900 m_scene.pMap = MapMetaData::GetUnderlying();
00901 }
00902
00908 inline void InitFrom(const SceneMetaData& other)
00909 {
00910 xnCopySceneMetaData(&m_scene, &other.m_scene);
00911 }
00912
00914 inline XnStatus InitFrom(const SceneMetaData& other, XnUInt32 nXRes, XnUInt32 nYRes, const XnLabel* pExternalBuffer)
00915 {
00916 InitFrom(other);
00917 return ReAdjust(nXRes, nYRes, pExternalBuffer);
00918 }
00919
00921 XnStatus CopyFrom(const SceneMetaData& other)
00922 {
00923
00924 xnCopySceneMetaData(&m_scene, &other.m_scene);
00925
00926 return MakeDataWritable();
00927 }
00928
00930 XnStatus ReAdjust(XnUInt32 nXRes, XnUInt32 nYRes, const XnLabel* pExternalBuffer = NULL)
00931 {
00932 return MapMetaData::ReAdjust(nXRes, nYRes, (const XnUInt8*)pExternalBuffer);
00933 }
00934
00936 inline const XnLabel* Data() const { return (const XnLabel*)MapMetaData::Data(); }
00938 inline const XnLabel*& Data() { return (const XnLabel*&)MapMetaData::Data(); }
00940 inline XnLabel* WritableData() { return (XnLabel*)MapMetaData::WritableData(); }
00941
00943 inline const xn::LabelMap& LabelMap() const { return m_labelMap; }
00945 inline xn::LabelMap& WritableLabelMap() { MakeDataWritable(); return m_writableLabelMap; }
00946
00952 inline const XnLabel& operator[](XnUInt32 nIndex) const
00953 {
00954 XN_ASSERT(nIndex < (XRes()*YRes()));
00955 return Data()[nIndex];
00956 }
00957
00964 inline const XnLabel& operator()(XnUInt32 x, XnUInt32 y) const
00965 {
00966 XN_ASSERT(x < XRes() && y < YRes());
00967 return (*this)[y*XRes() + x];
00968 }
00969
00971 inline const XnSceneMetaData* GetUnderlying() const { return &m_scene; }
00973 inline XnSceneMetaData* GetUnderlying() { return &m_scene; }
00974
00975 private:
00976
00977 SceneMetaData(const SceneMetaData& other);
00978 SceneMetaData& operator=(const SceneMetaData&);
00979
00980 XnSceneMetaData m_scene;
00981 const xn::LabelMap m_labelMap;
00982 xn::LabelMap m_writableLabelMap;
00983 };
00984
00985
00986
00987
00988
00993 class NodeWrapper
00994 {
00995 public:
00996 friend class Context;
00997
01003 inline NodeWrapper(XnNodeHandle hNode) : m_hNode(NULL), m_hShuttingDownCallback(NULL)
01004 {
01005 NodeWrapper::SetHandle(hNode);
01006 }
01007
01008 inline NodeWrapper(const NodeWrapper& other) : m_hNode(NULL), m_hShuttingDownCallback(NULL)
01009 {
01010 NodeWrapper::SetHandle(other.GetHandle());
01011 }
01012
01013 inline NodeWrapper& operator=(const NodeWrapper& other)
01014 {
01015 NodeWrapper::SetHandle(other.GetHandle());
01016 return *this;
01017 }
01018
01019 inline ~NodeWrapper()
01020 {
01021 NodeWrapper::SetHandle(NULL);
01022 }
01023
01024 inline operator XnNodeHandle() const { return GetHandle(); }
01025
01027 inline XnNodeHandle GetHandle() const { return m_hNode; }
01028
01034 inline XnBool operator==(const NodeWrapper& other)
01035 {
01036 return (GetHandle() == other.GetHandle());
01037 }
01038
01044 inline XnBool operator!=(const NodeWrapper& other)
01045 {
01046 return (GetHandle() != other.GetHandle());
01047 }
01048
01050 inline XnBool IsValid() const { return (GetHandle() != NULL); }
01051
01055 const XnChar* GetName() const {return xnGetNodeName(GetHandle()); }
01056
01060 inline XnStatus AddRef() { return xnProductionNodeAddRef(GetHandle()); }
01061
01065 inline void Release()
01066 {
01067 NodeWrapper::SetHandle(NULL);
01068 }
01069
01070 inline XnStatus XN_API_DEPRECATED("Please use AddRef() instead.") Ref() { return AddRef(); }
01071 inline void XN_API_DEPRECATED("Please use Release() instead.") Unref() { Release(); }
01072
01074 inline void SetHandle(XnNodeHandle hNode)
01075 {
01076 if (m_hNode == hNode)
01077 {
01078
01079 return;
01080 }
01081
01082
01083 if (m_hNode != NULL)
01084 {
01085 XnContext* pContext = xnGetRefContextFromNodeHandle(m_hNode);
01086 xnContextUnregisterFromShutdown(pContext, m_hShuttingDownCallback);
01087 xnContextRelease(pContext);
01088 xnProductionNodeRelease(m_hNode);
01089 }
01090
01091
01092 if (hNode != NULL)
01093 {
01094 XnStatus nRetVal = xnProductionNodeAddRef(hNode);
01095 XN_ASSERT(nRetVal == XN_STATUS_OK);
01096
01097 XnContext* pContext = xnGetRefContextFromNodeHandle(hNode);
01098
01099 nRetVal = xnContextRegisterForShutdown(pContext, ContextShuttingDownCallback, this, &m_hShuttingDownCallback);
01100 XN_ASSERT(nRetVal == XN_STATUS_OK);
01101
01102 xnContextRelease(pContext);
01103 }
01104
01105 m_hNode = hNode;
01106 }
01107
01108 inline void TakeOwnership(XnNodeHandle hNode)
01109 {
01110 SetHandle(hNode);
01111
01112 if (hNode != NULL)
01113 {
01114 xnProductionNodeRelease(hNode);
01115 }
01116 }
01117
01118 private:
01119 XnNodeHandle m_hNode;
01120 XnCallbackHandle m_hShuttingDownCallback;
01121
01122 static void XN_CALLBACK_TYPE ContextShuttingDownCallback(XnContext* , void* pCookie)
01123 {
01124 NodeWrapper* pThis = (NodeWrapper*)pCookie;
01125 pThis->m_hNode = NULL;
01126 }
01127 };
01128
01129
01130
01131
01132
01137 class NodeInfo
01138 {
01139 public:
01145 NodeInfo(XnNodeInfo* pInfo) : m_pNeededNodes(NULL), m_bOwnerOfNode(FALSE)
01146 {
01147 SetUnderlyingObject(pInfo);
01148 }
01149
01156 NodeInfo(const NodeInfo& other) : m_pNeededNodes(NULL), m_bOwnerOfNode(FALSE)
01157 {
01158 SetUnderlyingObject(other.m_pInfo);
01159 }
01160
01162 ~NodeInfo()
01163 {
01164 SetUnderlyingObject(NULL);
01165 }
01166
01172 inline NodeInfo& operator=(const NodeInfo& other)
01173 {
01174 SetUnderlyingObject(other.m_pInfo);
01175 return *this;
01176 }
01177
01179 inline operator XnNodeInfo*()
01180 {
01181 return m_pInfo;
01182 }
01183
01187 inline XnStatus SetInstanceName(const XnChar* strName)
01188 {
01189 return xnNodeInfoSetInstanceName(m_pInfo, strName);
01190 }
01191
01195 inline const XnProductionNodeDescription& GetDescription() const
01196 {
01197 return *xnNodeInfoGetDescription(m_pInfo);
01198 }
01199
01203 inline const XnChar* GetInstanceName() const
01204 {
01205 return xnNodeInfoGetInstanceName(m_pInfo);
01206 }
01207 inline const XnChar* GetCreationInfo() const
01211 {
01212 return xnNodeInfoGetCreationInfo(m_pInfo);
01213 }
01214
01218 inline NodeInfoList& GetNeededNodes() const;
01219
01227 inline XnStatus GetInstance(ProductionNode& node) const;
01228
01232 inline const void* GetAdditionalData() const
01233 {
01234 return xnNodeInfoGetAdditionalData(m_pInfo);
01235 }
01236
01237 private:
01238 inline void SetUnderlyingObject(XnNodeInfo* pInfo);
01239
01240 XnNodeInfo* m_pInfo;
01241 mutable NodeInfoList* m_pNeededNodes;
01242 XnBool m_bOwnerOfNode;
01243 friend class Context;
01244 };
01245
01246
01247
01248
01249
01255 class Query
01256 {
01257 public:
01259 inline Query() : m_bAllocated(TRUE)
01260 {
01261 xnNodeQueryAllocate(&m_pQuery);
01262 }
01263
01264 inline Query(XnNodeQuery* pNodeQuery) : m_pQuery(pNodeQuery), m_bAllocated(FALSE)
01265 {
01266 }
01267
01269 ~Query()
01270 {
01271 if (m_bAllocated)
01272 {
01273 xnNodeQueryFree(m_pQuery);
01274 }
01275 }
01276
01278 inline const XnNodeQuery* GetUnderlyingObject() const { return m_pQuery; }
01279 inline XnNodeQuery* GetUnderlyingObject() { return m_pQuery; }
01280
01284 inline XnStatus SetVendor(const XnChar* strVendor)
01285 {
01286 return xnNodeQuerySetVendor(m_pQuery, strVendor);
01287 }
01288
01292 inline XnStatus SetName(const XnChar* strName)
01293 {
01294 return xnNodeQuerySetName(m_pQuery, strName);
01295 }
01296
01300 inline XnStatus SetMinVersion(const XnVersion& minVersion)
01301 {
01302 return xnNodeQuerySetMinVersion(m_pQuery, &minVersion);
01303 }
01304
01308 inline XnStatus SetMaxVersion(const XnVersion& maxVersion)
01309 {
01310 return xnNodeQuerySetMaxVersion(m_pQuery, &maxVersion);
01311 }
01312
01316 inline XnStatus AddSupportedCapability(const XnChar* strNeededCapability)
01317 {
01318 return xnNodeQueryAddSupportedCapability(m_pQuery, strNeededCapability);
01319 }
01320
01324 inline XnStatus AddSupportedMapOutputMode(const XnMapOutputMode& MapOutputMode)
01325 {
01326 return xnNodeQueryAddSupportedMapOutputMode(m_pQuery, &MapOutputMode);
01327 }
01328
01332 inline XnStatus SetSupportedMinUserPositions(const XnUInt32 nCount)
01333 {
01334 return xnNodeQuerySetSupportedMinUserPositions(m_pQuery, nCount);
01335 }
01336
01340 inline XnStatus SetExistingNodeOnly(XnBool bExistingNode)
01341 {
01342 return xnNodeQuerySetExistingNodeOnly(m_pQuery, bExistingNode);
01343 }
01344
01348 inline XnStatus AddNeededNode(const XnChar* strInstanceName)
01349 {
01350 return xnNodeQueryAddNeededNode(m_pQuery, strInstanceName);
01351 }
01352
01356 inline XnStatus SetCreationInfo(const XnChar* strCreationInfo)
01357 {
01358 return xnNodeQuerySetCreationInfo(m_pQuery, strCreationInfo);
01359 }
01360
01361 private:
01362 XnNodeQuery* m_pQuery;
01363 XnBool m_bAllocated;
01364 };
01365
01366
01367
01368
01369
01374 class NodeInfoList
01375 {
01376 public:
01378 class Iterator
01379 {
01380 public:
01381 friend class NodeInfoList;
01382
01388 XnBool operator==(const Iterator& other) const
01389 {
01390 return m_it.pCurrent == other.m_it.pCurrent;
01391 }
01392
01398 XnBool operator!=(const Iterator& other) const
01399 {
01400 return m_it.pCurrent != other.m_it.pCurrent;
01401 }
01402
01407 inline Iterator& operator++()
01408 {
01409 UpdateInternalObject(xnNodeInfoListGetNext(m_it));
01410 return *this;
01411 }
01412
01417 inline Iterator operator++(int)
01418 {
01419 XnNodeInfoListIterator curr = m_it;
01420 UpdateInternalObject(xnNodeInfoListGetNext(m_it));
01421 return Iterator(curr);
01422 }
01423
01427 inline Iterator& operator--()
01428 {
01429 UpdateInternalObject(xnNodeInfoListGetPrevious(m_it));
01430 return *this;
01431 }
01432
01436 inline Iterator operator--(int)
01437 {
01438 XnNodeInfoListIterator curr = m_it;
01439 UpdateInternalObject(xnNodeInfoListGetPrevious(m_it));
01440 return Iterator(curr);
01441 }
01442
01444 inline NodeInfo operator*()
01445 {
01446 return m_Info;
01447 }
01448
01449 private:
01450 inline Iterator(XnNodeInfoListIterator it) : m_Info(NULL)
01451 {
01452 UpdateInternalObject(it);
01453 }
01454
01455 inline void UpdateInternalObject(XnNodeInfoListIterator it)
01456 {
01457 m_it = it;
01458 if (xnNodeInfoListIteratorIsValid(it))
01459 {
01460 XnNodeInfo* pInfo = xnNodeInfoListGetCurrent(it);
01461 m_Info = NodeInfo(pInfo);
01462 }
01463 else
01464 {
01465 m_Info = NodeInfo(NULL);
01466 }
01467 }
01468
01469 NodeInfo m_Info;
01470 XnNodeInfoListIterator m_it;
01471 };
01472
01476 inline NodeInfoList()
01477 {
01478 xnNodeInfoListAllocate(&m_pList);
01479 m_bAllocated = TRUE;
01480 }
01481
01488 inline NodeInfoList(XnNodeInfoList* pList) : m_pList(pList), m_bAllocated(FALSE) {}
01489
01491 inline ~NodeInfoList()
01492 {
01493 FreeImpl();
01494 }
01495
01497 inline XnNodeInfoList* GetUnderlyingObject() const { return m_pList; }
01498
01505 inline void ReplaceUnderlyingObject(XnNodeInfoList* pList)
01506 {
01507 FreeImpl();
01508 m_pList = pList;
01509 m_bAllocated = TRUE;
01510 }
01511
01515 inline XnStatus Add(XnProductionNodeDescription& description, const XnChar* strCreationInfo, NodeInfoList* pNeededNodes)
01516 {
01517 XnNodeInfoList* pList = (pNeededNodes == NULL) ? NULL : pNeededNodes->GetUnderlyingObject();
01518 return xnNodeInfoListAdd(m_pList, &description, strCreationInfo, pList);
01519 }
01520
01524 inline XnStatus AddEx(XnProductionNodeDescription& description, const XnChar* strCreationInfo, NodeInfoList* pNeededNodes, const void* pAdditionalData, XnFreeHandler pFreeHandler)
01525 {
01526 XnNodeInfoList* pList = (pNeededNodes == NULL) ? NULL : pNeededNodes->GetUnderlyingObject();
01527 return xnNodeInfoListAddEx(m_pList, &description, strCreationInfo, pList, pAdditionalData, pFreeHandler);
01528 }
01529
01533 inline XnStatus AddNode(NodeInfo& info)
01534 {
01535 return xnNodeInfoListAddNode(m_pList, info);
01536 }
01537
01541 inline XnStatus AddNodeFromAnotherList(Iterator& it)
01542 {
01543 return xnNodeInfoListAddNodeFromList(m_pList, it.m_it);
01544 }
01545
01547 inline Iterator Begin() const
01548 {
01549 return Iterator(xnNodeInfoListGetFirst(m_pList));
01550 }
01551
01553 inline Iterator End() const
01554 {
01555 XnNodeInfoListIterator it = { NULL };
01556 return Iterator(it);
01557 }
01558
01560 inline Iterator RBegin() const
01561 {
01562 return Iterator(xnNodeInfoListGetLast(m_pList));
01563 }
01564
01566 inline Iterator REnd() const
01567 {
01568 XnNodeInfoListIterator it = { NULL };
01569 return Iterator(it);
01570 }
01571
01575 inline XnStatus Remove(Iterator& it)
01576 {
01577 return xnNodeInfoListRemove(m_pList, it.m_it);
01578 }
01579
01583 inline XnStatus Clear()
01584 {
01585 return xnNodeInfoListClear(m_pList);
01586 }
01587
01591 inline XnStatus Append(NodeInfoList& other)
01592 {
01593 return xnNodeInfoListAppend(m_pList, other.GetUnderlyingObject());
01594 }
01595
01599 inline XnBool IsEmpty()
01600 {
01601 return xnNodeInfoListIsEmpty(m_pList);
01602 }
01603
01607 inline XnStatus FilterList(Context& context, Query& query);
01608
01609 private:
01610 inline void FreeImpl()
01611 {
01612 if (m_bAllocated)
01613 {
01614 xnNodeInfoListFree(m_pList);
01615 m_bAllocated = FALSE;
01616 m_pList = NULL;
01617 }
01618 }
01619
01620 XnNodeInfoList* m_pList;
01621 XnBool m_bAllocated;
01622 };
01623
01624
01625
01626
01627
01632 class Capability : public NodeWrapper
01633 {
01634 public:
01640 Capability(XnNodeHandle hNode) : NodeWrapper(hNode) {}
01641 Capability(const NodeWrapper& node) : NodeWrapper(node) {}
01642 };
01643
01648 class ErrorStateCapability : public Capability
01649 {
01650 public:
01656 ErrorStateCapability(XnNodeHandle hNode) : Capability(hNode) {}
01657 ErrorStateCapability(const NodeWrapper& node) : Capability(node) {}
01658
01662 inline XnStatus GetErrorState() const
01663 {
01664 return xnGetNodeErrorState(GetHandle());
01665 }
01666
01670 inline XnStatus RegisterToErrorStateChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
01671 {
01672 return _RegisterToStateChange(xnRegisterToNodeErrorStateChange, GetHandle(), handler, pCookie, hCallback);
01673 }
01674
01678 inline void UnregisterFromErrorStateChange(XnCallbackHandle hCallback)
01679 {
01680 _UnregisterFromStateChange(xnUnregisterFromNodeErrorStateChange, GetHandle(), hCallback);
01681 }
01682 };
01683
01688 class GeneralIntCapability : public Capability
01689 {
01690 public:
01697 GeneralIntCapability(XnNodeHandle hNode, const XnChar* strCap) : Capability(hNode), m_strCap(strCap) {}
01698 GeneralIntCapability(const NodeWrapper& node) : Capability(node) {}
01699
01703 inline void GetRange(XnInt32& nMin, XnInt32& nMax, XnInt32& nStep, XnInt32& nDefault, XnBool& bIsAutoSupported) const
01704 {
01705 xnGetGeneralIntRange(GetHandle(), m_strCap, &nMin, &nMax, &nStep, &nDefault, &bIsAutoSupported);
01706 }
01707
01711 inline XnInt32 Get()
01712 {
01713 XnInt32 nValue;
01714 xnGetGeneralIntValue(GetHandle(), m_strCap, &nValue);
01715 return nValue;
01716 }
01717
01721 inline XnStatus Set(XnInt32 nValue)
01722 {
01723 return xnSetGeneralIntValue(GetHandle(), m_strCap, nValue);
01724 }
01725
01729 XnStatus RegisterToValueChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback);
01730
01734 void UnregisterFromValueChange(XnCallbackHandle hCallback);
01735
01736 private:
01737 const XnChar* m_strCap;
01738 };
01739
01744 class ProductionNode : public NodeWrapper
01745 {
01746 public:
01752 inline ProductionNode(XnNodeHandle hNode = NULL) : NodeWrapper(hNode) {}
01753 inline ProductionNode(const NodeWrapper& other) : NodeWrapper(other) {}
01754
01758 inline NodeInfo GetInfo() const { return NodeInfo(xnGetNodeInfo(GetHandle())); }
01759
01763 inline XnStatus AddNeededNode(ProductionNode& needed)
01764 {
01765 return xnAddNeededNode(GetHandle(), needed.GetHandle());
01766 }
01767
01771 inline XnStatus RemoveNeededNode(ProductionNode& needed)
01772 {
01773 return xnRemoveNeededNode(GetHandle(), needed.GetHandle());
01774 }
01775
01779 inline void GetContext(Context& context) const;
01780
01784 inline XnBool IsCapabilitySupported(const XnChar* strCapabilityName) const
01785 {
01786 return xnIsCapabilitySupported(GetHandle(), strCapabilityName);
01787 }
01788
01792 inline XnStatus SetIntProperty(const XnChar* strName, XnUInt64 nValue)
01793 {
01794 return xnSetIntProperty(GetHandle(), strName, nValue);
01795 }
01796
01800 inline XnStatus SetRealProperty(const XnChar* strName, XnDouble dValue)
01801 {
01802 return xnSetRealProperty(GetHandle(), strName, dValue);
01803 }
01804
01808 inline XnStatus SetStringProperty(const XnChar* strName, const XnChar* strValue)
01809 {
01810 return xnSetStringProperty(GetHandle(), strName, strValue);
01811 }
01812
01816 inline XnStatus SetGeneralProperty(const XnChar* strName, XnUInt32 nBufferSize, const void* pBuffer)
01817 {
01818 return xnSetGeneralProperty(GetHandle(), strName, nBufferSize, pBuffer);
01819 }
01820
01824 inline XnStatus GetIntProperty(const XnChar* strName, XnUInt64& nValue) const
01825 {
01826 return xnGetIntProperty(GetHandle(), strName, &nValue);
01827 }
01828
01832 inline XnStatus GetRealProperty(const XnChar* strName, XnDouble &dValue) const
01833 {
01834 return xnGetRealProperty(GetHandle(), strName, &dValue);
01835 }
01836
01840 inline XnStatus GetStringProperty(const XnChar* strName, XnChar* csValue, XnUInt32 nBufSize) const
01841 {
01842 return xnGetStringProperty(GetHandle(), strName, csValue, nBufSize);
01843 }
01844
01848 inline XnStatus GetGeneralProperty(const XnChar* strName, XnUInt32 nBufferSize, void* pBuffer) const
01849 {
01850 return xnGetGeneralProperty(GetHandle(), strName, nBufferSize, pBuffer);
01851 }
01852
01856 inline XnStatus LockForChanges(XnLockHandle* phLock)
01857 {
01858 return xnLockNodeForChanges(GetHandle(), phLock);
01859 }
01860
01864 inline void UnlockForChanges(XnLockHandle hLock)
01865 {
01866 xnUnlockNodeForChanges(GetHandle(), hLock);
01867 }
01868
01872 inline XnStatus LockedNodeStartChanges(XnLockHandle hLock)
01873 {
01874 return xnLockedNodeStartChanges(GetHandle(), hLock);
01875 }
01876
01880 inline void LockedNodeEndChanges(XnLockHandle hLock)
01881 {
01882 xnLockedNodeEndChanges(GetHandle(), hLock);
01883 }
01884
01890 inline const ErrorStateCapability GetErrorStateCap() const
01891 {
01892 return ErrorStateCapability(GetHandle());
01893 }
01894
01900 inline ErrorStateCapability GetErrorStateCap()
01901 {
01902 return ErrorStateCapability(GetHandle());
01903 }
01904
01912 inline GeneralIntCapability GetGeneralIntCap(const XnChar* strCapability)
01913 {
01914 return GeneralIntCapability(GetHandle(), strCapability);
01915 }
01916 };
01917
01922 class DeviceIdentificationCapability : public Capability
01923 {
01924 public:
01930 DeviceIdentificationCapability(XnNodeHandle hNode) : Capability(hNode) {}
01931 DeviceIdentificationCapability(const NodeWrapper& node) : Capability(node) {}
01932
01936 inline XnStatus GetDeviceName(XnChar* strBuffer, XnUInt32 nBufferSize)
01937 {
01938 return xnGetDeviceName(GetHandle(), strBuffer, &nBufferSize);
01939 }
01940
01944 inline XnStatus GetVendorSpecificData(XnChar* strBuffer, XnUInt32 nBufferSize)
01945 {
01946 return xnGetVendorSpecificData(GetHandle(), strBuffer, &nBufferSize);
01947 }
01948
01952 inline XnStatus GetSerialNumber(XnChar* strBuffer, XnUInt32 nBufferSize)
01953 {
01954 return xnGetSerialNumber(GetHandle(), strBuffer, &nBufferSize);
01955 }
01956 };
01957
01962 class Device : public ProductionNode
01963 {
01964 public:
01970 inline Device(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {}
01971 inline Device(const NodeWrapper& other) : ProductionNode(other) {}
01972
01976 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL);
01977
01983 inline DeviceIdentificationCapability GetIdentificationCap()
01984 {
01985 return DeviceIdentificationCapability(GetHandle());
01986 }
01987 };
01988
01993 class MirrorCapability : public Capability
01994 {
01995 public:
02001 inline MirrorCapability(XnNodeHandle hNode) : Capability(hNode) {}
02002 MirrorCapability(const NodeWrapper& node) : Capability(node) {}
02003
02007 inline XnStatus SetMirror(XnBool bMirror)
02008 {
02009 return xnSetMirror(GetHandle(), bMirror);
02010 }
02011
02015 inline XnBool IsMirrored() const
02016 {
02017 return xnIsMirrored(GetHandle());
02018 }
02019
02023 inline XnStatus RegisterToMirrorChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
02024 {
02025 return _RegisterToStateChange(xnRegisterToMirrorChange, GetHandle(), handler, pCookie, hCallback);
02026 }
02027
02031 inline void UnregisterFromMirrorChange(XnCallbackHandle hCallback)
02032 {
02033 _UnregisterFromStateChange(xnUnregisterFromMirrorChange, GetHandle(), hCallback);
02034 }
02035 };
02036
02041 class AlternativeViewPointCapability : public Capability
02042 {
02043 public:
02049 inline AlternativeViewPointCapability(XnNodeHandle hNode) : Capability(hNode) {}
02050 AlternativeViewPointCapability(const NodeWrapper& node) : Capability(node) {}
02051
02055 inline XnBool IsViewPointSupported(ProductionNode& otherNode) const
02056 {
02057 return xnIsViewPointSupported(GetHandle(), otherNode.GetHandle());
02058 }
02059
02063 inline XnStatus SetViewPoint(ProductionNode& otherNode)
02064 {
02065 return xnSetViewPoint(GetHandle(), otherNode.GetHandle());
02066 }
02067
02071 inline XnStatus ResetViewPoint()
02072 {
02073 return xnResetViewPoint(GetHandle());
02074 }
02075
02079 inline XnBool IsViewPointAs(ProductionNode& otherNode) const
02080 {
02081 return xnIsViewPointAs(GetHandle(), otherNode.GetHandle());
02082 }
02083
02087 inline XnStatus RegisterToViewPointChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
02088 {
02089 return _RegisterToStateChange(xnRegisterToViewPointChange, GetHandle(), handler, pCookie, hCallback);
02090 }
02091
02095 inline void UnregisterFromViewPointChange(XnCallbackHandle hCallback)
02096 {
02097 _UnregisterFromStateChange(xnUnregisterFromViewPointChange, GetHandle(), hCallback);
02098 }
02099 };
02100
02105 class FrameSyncCapability : public Capability
02106 {
02107 public:
02113 inline FrameSyncCapability(XnNodeHandle hNode) : Capability(hNode) {}
02114 FrameSyncCapability(const NodeWrapper& node) : Capability(node) {}
02115
02119 inline XnBool CanFrameSyncWith(Generator& other) const;
02120
02124 inline XnStatus FrameSyncWith(Generator& other);
02125
02129 inline XnStatus StopFrameSyncWith(Generator& other);
02130
02134 inline XnBool IsFrameSyncedWith(Generator& other) const;
02135
02139 inline XnStatus RegisterToFrameSyncChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
02140 {
02141 return _RegisterToStateChange(xnRegisterToFrameSyncChange, GetHandle(), handler, pCookie, hCallback);
02142 }
02143
02147 inline void UnregisterFromFrameSyncChange(XnCallbackHandle hCallback)
02148 {
02149 _UnregisterFromStateChange(xnUnregisterFromFrameSyncChange, GetHandle(), hCallback);
02150 }
02151 };
02152
02157 class Generator : public ProductionNode
02158 {
02159 public:
02165 inline Generator(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {}
02166 inline Generator(const NodeWrapper& other) : ProductionNode(other) {}
02167
02171 inline XnStatus StartGenerating()
02172 {
02173 return xnStartGenerating(GetHandle());
02174 }
02175
02179 inline XnBool IsGenerating() const
02180 {
02181 return xnIsGenerating(GetHandle());
02182 }
02183
02187 inline XnStatus StopGenerating()
02188 {
02189 return xnStopGenerating(GetHandle());
02190 }
02191
02195 inline XnStatus RegisterToGenerationRunningChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle &hCallback)
02196 {
02197 return _RegisterToStateChange(xnRegisterToGenerationRunningChange, GetHandle(), handler, pCookie, hCallback);
02198 }
02199
02203 inline void UnregisterFromGenerationRunningChange(XnCallbackHandle hCallback)
02204 {
02205 _UnregisterFromStateChange(xnUnregisterFromGenerationRunningChange, GetHandle(), hCallback);
02206 }
02207
02211 inline XnStatus RegisterToNewDataAvailable(StateChangedHandler handler, void* pCookie, XnCallbackHandle &hCallback)
02212 {
02213 return _RegisterToStateChange(xnRegisterToNewDataAvailable, GetHandle(), handler, pCookie, hCallback);
02214 }
02215
02219 inline void UnregisterFromNewDataAvailable(XnCallbackHandle hCallback)
02220 {
02221 _UnregisterFromStateChange(xnUnregisterFromNewDataAvailable, GetHandle(), hCallback);
02222 }
02223
02227 inline XnBool IsNewDataAvailable(XnUInt64* pnTimestamp = NULL) const
02228 {
02229 return xnIsNewDataAvailable(GetHandle(), pnTimestamp);
02230 }
02231
02235 inline XnStatus WaitAndUpdateData()
02236 {
02237 return xnWaitAndUpdateData(GetHandle());
02238 }
02239
02243 inline XnBool IsDataNew() const
02244 {
02245 return xnIsDataNew(GetHandle());
02246 }
02247
02251 inline const void* GetData()
02252 {
02253 return xnGetData(GetHandle());
02254 }
02255
02259 inline XnUInt32 GetDataSize() const
02260 {
02261 return xnGetDataSize(GetHandle());
02262 }
02263
02267 inline XnUInt64 GetTimestamp() const
02268 {
02269 return xnGetTimestamp(GetHandle());
02270 }
02271
02275 inline XnUInt32 GetFrameID() const
02276 {
02277 return xnGetFrameID(GetHandle());
02278 }
02279
02285 inline const MirrorCapability GetMirrorCap() const
02286 {
02287 return MirrorCapability(GetHandle());
02288 }
02289
02295 inline MirrorCapability GetMirrorCap()
02296 {
02297 return MirrorCapability(GetHandle());
02298 }
02299
02305 inline const AlternativeViewPointCapability GetAlternativeViewPointCap() const
02306 {
02307 return AlternativeViewPointCapability(GetHandle());
02308 }
02309
02315 inline AlternativeViewPointCapability GetAlternativeViewPointCap()
02316 {
02317 return AlternativeViewPointCapability(GetHandle());
02318 }
02319
02325 inline const FrameSyncCapability GetFrameSyncCap() const
02326 {
02327 return FrameSyncCapability(GetHandle());
02328 }
02329
02335 inline FrameSyncCapability GetFrameSyncCap()
02336 {
02337 return FrameSyncCapability(GetHandle());
02338 }
02339 };
02340
02345 class Recorder : public ProductionNode
02346 {
02347 public:
02353 inline Recorder(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {}
02354 inline Recorder(const NodeWrapper& other) : ProductionNode(other) {}
02355
02359 inline XnStatus Create(Context& context, const XnChar* strFormatName = NULL);
02360
02364 inline XnStatus SetDestination(XnRecordMedium destType, const XnChar* strDest)
02365 {
02366 return xnSetRecorderDestination(GetHandle(), destType, strDest);
02367 }
02368
02369 inline XnStatus GetDestination(XnRecordMedium& destType, XnChar* strDest, XnUInt32 nBufSize)
02370 {
02371 return xnGetRecorderDestination(GetHandle(), &destType, strDest, nBufSize);
02372 }
02373
02377 inline XnStatus AddNodeToRecording(ProductionNode& Node, XnCodecID compression = XN_CODEC_NULL)
02378 {
02379 return xnAddNodeToRecording(GetHandle(), Node.GetHandle(), compression);
02380 }
02381
02385 inline XnStatus RemoveNodeFromRecording(ProductionNode& Node)
02386 {
02387 return xnRemoveNodeFromRecording(GetHandle(), Node.GetHandle());
02388 }
02389
02393 inline XnStatus Record()
02394 {
02395 return xnRecord(GetHandle());
02396 }
02397 };
02398
02403 class Player : public ProductionNode
02404 {
02405 public:
02411 inline Player(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {}
02412 inline Player(const NodeWrapper& other) : ProductionNode(other) {}
02413
02417 inline XnStatus Create(Context& context, const XnChar* strFormatName);
02418
02422 inline XnStatus SetRepeat(XnBool bRepeat)
02423 {
02424 return xnSetPlayerRepeat(GetHandle(), bRepeat);
02425 }
02426
02430 inline XnStatus SetSource(XnRecordMedium sourceType, const XnChar* strSource)
02431 {
02432 return xnSetPlayerSource(GetHandle(), sourceType, strSource);
02433 }
02434
02438 inline XnStatus GetSource(XnRecordMedium &sourceType, XnChar* strSource, XnUInt32 nBufSize) const
02439 {
02440 return xnGetPlayerSource(GetHandle(), &sourceType, strSource, nBufSize);
02441 }
02442
02446 inline XnStatus ReadNext()
02447 {
02448 return xnPlayerReadNext(GetHandle());
02449 }
02450
02454 inline XnStatus SeekToTimeStamp(XnInt64 nTimeOffset, XnPlayerSeekOrigin origin)
02455 {
02456 return xnSeekPlayerToTimeStamp(GetHandle(), nTimeOffset, origin);
02457 }
02458
02462 inline XnStatus SeekToFrame(const XnChar* strNodeName, XnInt32 nFrameOffset, XnPlayerSeekOrigin origin)
02463 {
02464 return xnSeekPlayerToFrame(GetHandle(), strNodeName, nFrameOffset, origin);
02465 }
02466
02470 inline XnStatus TellTimestamp(XnUInt64& nTimestamp) const
02471 {
02472 return xnTellPlayerTimestamp(GetHandle(), &nTimestamp);
02473 }
02474
02478 inline XnStatus TellFrame(const XnChar* strNodeName, XnUInt32& nFrame) const
02479 {
02480 return xnTellPlayerFrame(GetHandle(), strNodeName, &nFrame);
02481 }
02482
02486 inline XnStatus GetNumFrames(const XnChar* strNodeName, XnUInt32& nFrames) const
02487 {
02488 return xnGetPlayerNumFrames(GetHandle(), strNodeName, &nFrames);
02489 }
02490
02494 inline const XnChar* GetSupportedFormat() const
02495 {
02496 return xnGetPlayerSupportedFormat(GetHandle());
02497 }
02498
02502 inline XnStatus EnumerateNodes(NodeInfoList& list) const
02503 {
02504 XnNodeInfoList* pList;
02505 XnStatus nRetVal = xnEnumeratePlayerNodes(GetHandle(), &pList);
02506 XN_IS_STATUS_OK(nRetVal);
02507
02508 list.ReplaceUnderlyingObject(pList);
02509
02510 return (XN_STATUS_OK);
02511 }
02512
02516 inline XnBool IsEOF() const
02517 {
02518 return xnIsPlayerAtEOF(GetHandle());
02519 }
02520
02524 inline XnStatus RegisterToEndOfFileReached(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
02525 {
02526 return _RegisterToStateChange(xnRegisterToEndOfFileReached, GetHandle(), handler, pCookie, hCallback);
02527 }
02528
02532 inline void UnregisterFromEndOfFileReached(XnCallbackHandle hCallback)
02533 {
02534 _UnregisterFromStateChange(xnUnregisterFromEndOfFileReached, GetHandle(), hCallback);
02535 }
02536
02540 inline XnStatus SetPlaybackSpeed(XnDouble dSpeed)
02541 {
02542 return xnSetPlaybackSpeed(GetHandle(), dSpeed);
02543 }
02544
02548 inline XnDouble GetPlaybackSpeed() const
02549 {
02550 return xnGetPlaybackSpeed(GetHandle());
02551 }
02552 };
02553
02558 class CroppingCapability : public Capability
02559 {
02560 public:
02566 inline CroppingCapability(XnNodeHandle hNode) : Capability(hNode) {}
02567 CroppingCapability(const NodeWrapper& node) : Capability(node) {}
02568
02572 inline XnStatus SetCropping(const XnCropping& Cropping)
02573 {
02574 return xnSetCropping(GetHandle(), &Cropping);
02575 }
02576
02580 inline XnStatus GetCropping(XnCropping& Cropping) const
02581 {
02582 return xnGetCropping(GetHandle(), &Cropping);
02583 }
02584
02588 inline XnStatus RegisterToCroppingChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
02589 {
02590 return _RegisterToStateChange(xnRegisterToCroppingChange, GetHandle(), handler, pCookie, hCallback);
02591 }
02592
02596 inline void UnregisterFromCroppingChange(XnCallbackHandle hCallback)
02597 {
02598 _UnregisterFromStateChange(xnUnregisterFromCroppingChange, GetHandle(), hCallback);
02599 }
02600 };
02601
02606 class AntiFlickerCapability : public Capability
02607 {
02608 public:
02614 inline AntiFlickerCapability(XnNodeHandle hNode) : Capability(hNode) {}
02615 AntiFlickerCapability(const NodeWrapper& node) : Capability(node) {}
02616
02620 inline XnStatus SetPowerLineFrequency(XnPowerLineFrequency nFrequency)
02621 {
02622 return xnSetPowerLineFrequency(GetHandle(), nFrequency);
02623 }
02624
02628 inline XnPowerLineFrequency GetPowerLineFrequency()
02629 {
02630 return xnGetPowerLineFrequency(GetHandle());
02631 }
02632
02636 inline XnStatus RegisterToPowerLineFrequencyChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
02637 {
02638 return _RegisterToStateChange(xnRegisterToPowerLineFrequencyChange, GetHandle(), handler, pCookie, hCallback);
02639 }
02640
02644 inline void UnregisterFromPowerLineFrequencyChange(XnCallbackHandle hCallback)
02645 {
02646 _UnregisterFromStateChange(xnUnregisterFromPowerLineFrequencyChange, GetHandle(), hCallback);
02647 }
02648 };
02649
02654 class MapGenerator : public Generator
02655 {
02656 public:
02662 inline MapGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {}
02663 inline MapGenerator(const NodeWrapper& other) : Generator(other) {}
02664
02668 inline XnUInt32 GetSupportedMapOutputModesCount() const
02669 {
02670 return xnGetSupportedMapOutputModesCount(GetHandle());
02671 }
02672
02676 inline XnStatus GetSupportedMapOutputModes(XnMapOutputMode* aModes, XnUInt32& nCount) const
02677 {
02678 return xnGetSupportedMapOutputModes(GetHandle(), aModes, &nCount);
02679 }
02680
02684 inline XnStatus SetMapOutputMode(const XnMapOutputMode& OutputMode)
02685 {
02686 return xnSetMapOutputMode(GetHandle(), &OutputMode);
02687 }
02688
02692 inline XnStatus GetMapOutputMode(XnMapOutputMode &OutputMode) const
02693 {
02694 return xnGetMapOutputMode(GetHandle(), &OutputMode);
02695 }
02696
02700 inline XnUInt32 GetBytesPerPixel() const
02701 {
02702 return xnGetBytesPerPixel(GetHandle());
02703 }
02704
02708 inline XnStatus RegisterToMapOutputModeChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
02709 {
02710 return _RegisterToStateChange(xnRegisterToMapOutputModeChange, GetHandle(), handler, pCookie, hCallback);
02711 }
02712
02716 inline void UnregisterFromMapOutputModeChange(XnCallbackHandle hCallback)
02717 {
02718 _UnregisterFromStateChange(xnUnregisterFromMapOutputModeChange, GetHandle(), hCallback);
02719 }
02720
02726 inline const CroppingCapability GetCroppingCap() const
02727 {
02728 return CroppingCapability(GetHandle());
02729 }
02730
02736 inline CroppingCapability GetCroppingCap()
02737 {
02738 return CroppingCapability(GetHandle());
02739 }
02740
02746 inline GeneralIntCapability GetBrightnessCap()
02747 {
02748 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_BRIGHTNESS);
02749 }
02750
02756 inline GeneralIntCapability GetContrastCap()
02757 {
02758 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_CONTRAST);
02759 }
02760
02766 inline GeneralIntCapability GetHueCap()
02767 {
02768 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_HUE);
02769 }
02770
02776 inline GeneralIntCapability GetSaturationCap()
02777 {
02778 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_SATURATION);
02779 }
02780
02786 inline GeneralIntCapability GetSharpnessCap()
02787 {
02788 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_SHARPNESS);
02789 }
02790
02796 inline GeneralIntCapability GetGammaCap()
02797 {
02798 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_GAMMA);
02799 }
02800
02806 inline GeneralIntCapability GetWhiteBalanceCap()
02807 {
02808 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_COLOR_TEMPERATURE);
02809 }
02810
02816 inline GeneralIntCapability GetBacklightCompensationCap()
02817 {
02818 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_BACKLIGHT_COMPENSATION);
02819 }
02820
02826 inline GeneralIntCapability GetGainCap()
02827 {
02828 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_GAIN);
02829 }
02830
02836 inline GeneralIntCapability GetPanCap()
02837 {
02838 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_PAN);
02839 }
02840
02846 inline GeneralIntCapability GetTiltCap()
02847 {
02848 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_TILT);
02849 }
02850
02856 inline GeneralIntCapability GetRollCap()
02857 {
02858 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_ROLL);
02859 }
02860
02866 inline GeneralIntCapability GetZoomCap()
02867 {
02868 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_ZOOM);
02869 }
02870
02876 inline GeneralIntCapability GetExposureCap()
02877 {
02878 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_EXPOSURE);
02879 }
02880
02886 inline GeneralIntCapability GetIrisCap()
02887 {
02888 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_IRIS);
02889 }
02890
02896 inline GeneralIntCapability GetFocusCap()
02897 {
02898 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_FOCUS);
02899 }
02900
02906 inline GeneralIntCapability GetLowLightCompensationCap()
02907 {
02908 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_LOW_LIGHT_COMPENSATION);
02909 }
02910
02916 inline AntiFlickerCapability GetAntiFlickerCap()
02917 {
02918 return AntiFlickerCapability(GetHandle());
02919 }
02920 };
02921
02926 class UserPositionCapability : public Capability
02927 {
02928 public:
02934 inline UserPositionCapability(XnNodeHandle hNode = NULL) : Capability(hNode) {}
02935 UserPositionCapability(const NodeWrapper& node) : Capability(node) {}
02936
02940 inline XnUInt32 GetSupportedUserPositionsCount() const
02941 {
02942 return xnGetSupportedUserPositionsCount(GetHandle());
02943 }
02944
02948 inline XnStatus SetUserPosition(XnUInt32 nIndex, const XnBoundingBox3D& Position)
02949 {
02950 return xnSetUserPosition(GetHandle(), nIndex, &Position);
02951 }
02952
02956 inline XnStatus GetUserPosition(XnUInt32 nIndex, XnBoundingBox3D& Position) const
02957 {
02958 return xnGetUserPosition(GetHandle(), nIndex, &Position);
02959 }
02960
02964 inline XnStatus RegisterToUserPositionChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
02965 {
02966 return _RegisterToStateChange(xnRegisterToUserPositionChange, GetHandle(), handler, pCookie, hCallback);
02967 }
02968
02972 inline void UnregisterFromUserPositionChange(XnCallbackHandle hCallback)
02973 {
02974 _UnregisterFromStateChange(xnUnregisterFromUserPositionChange, GetHandle(), hCallback);
02975 }
02976 };
02977
02982 class DepthGenerator : public MapGenerator
02983 {
02984 public:
02990 inline DepthGenerator(XnNodeHandle hNode = NULL) : MapGenerator(hNode) {}
02991 inline DepthGenerator(const NodeWrapper& other) : MapGenerator(other) {}
02992
02996 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL);
02997
03001 inline void GetMetaData(DepthMetaData& metaData) const
03002 {
03003 xnGetDepthMetaData(GetHandle(), metaData.GetUnderlying());
03004 }
03005
03009 inline const XnDepthPixel* GetDepthMap() const
03010 {
03011 return xnGetDepthMap(GetHandle());
03012 }
03013
03017 inline XnDepthPixel GetDeviceMaxDepth() const
03018 {
03019 return xnGetDeviceMaxDepth(GetHandle());
03020 }
03021
03025 inline XnStatus GetFieldOfView(XnFieldOfView& FOV) const
03026 {
03027 return xnGetDepthFieldOfView(GetHandle(), &FOV);
03028 }
03029
03033 inline XnStatus RegisterToFieldOfViewChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
03034 {
03035 return _RegisterToStateChange(xnRegisterToDepthFieldOfViewChange, GetHandle(), handler, pCookie, hCallback);
03036 }
03037
03041 inline void UnregisterFromFieldOfViewChange(XnCallbackHandle hCallback)
03042 {
03043 _UnregisterFromStateChange(xnUnregisterFromDepthFieldOfViewChange, GetHandle(), hCallback);
03044 }
03045
03049 inline XnStatus ConvertProjectiveToRealWorld(XnUInt32 nCount, const XnPoint3D aProjective[], XnPoint3D aRealWorld[]) const
03050 {
03051 return xnConvertProjectiveToRealWorld(GetHandle(), nCount, aProjective, aRealWorld);
03052 }
03053
03057 inline XnStatus ConvertRealWorldToProjective(XnUInt32 nCount, const XnPoint3D aRealWorld[], XnPoint3D aProjective[]) const
03058 {
03059 return xnConvertRealWorldToProjective(GetHandle(), nCount, aRealWorld, aProjective);
03060 }
03061
03067 inline const UserPositionCapability GetUserPositionCap() const
03068 {
03069 return UserPositionCapability(GetHandle());
03070 }
03071
03077 inline UserPositionCapability GetUserPositionCap()
03078 {
03079 return UserPositionCapability(GetHandle());
03080 }
03081 };
03082
03087 class MockDepthGenerator : public DepthGenerator
03088 {
03089 public:
03095 inline MockDepthGenerator(XnNodeHandle hNode = NULL) : DepthGenerator(hNode) {}
03096 inline MockDepthGenerator(const NodeWrapper& other) : DepthGenerator(other) {}
03097
03104 XnStatus Create(Context& context, const XnChar* strName = NULL);
03105
03112 XnStatus CreateBasedOn(DepthGenerator& other, const XnChar* strName = NULL);
03113
03117 inline XnStatus SetData(XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize, const XnDepthPixel* pDepthMap)
03118 {
03119 return xnMockDepthSetData(GetHandle(), nFrameID, nTimestamp, nDataSize, pDepthMap);
03120 }
03121
03129 inline XnStatus SetData(const DepthMetaData& depthMD, XnUInt32 nFrameID, XnUInt64 nTimestamp)
03130 {
03131 return SetData(nFrameID, nTimestamp, depthMD.DataSize(), depthMD.Data());
03132 }
03133
03139 inline XnStatus SetData(const DepthMetaData& depthMD)
03140 {
03141 return SetData(depthMD, depthMD.FrameID(), depthMD.Timestamp());
03142 }
03143 };
03144
03149 class ImageGenerator : public MapGenerator
03150 {
03151 public:
03157 inline ImageGenerator(XnNodeHandle hNode = NULL) : MapGenerator(hNode) {}
03158 inline ImageGenerator(const NodeWrapper& other) : MapGenerator(other) {}
03159
03163 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL);
03164
03168 inline void GetMetaData(ImageMetaData& metaData) const
03169 {
03170 xnGetImageMetaData(GetHandle(), metaData.GetUnderlying());
03171 }
03172
03176 inline const XnRGB24Pixel* GetRGB24ImageMap() const
03177 {
03178 return xnGetRGB24ImageMap(GetHandle());
03179 }
03180
03184 inline const XnYUV422DoublePixel* GetYUV422ImageMap() const
03185 {
03186 return xnGetYUV422ImageMap(GetHandle());
03187 }
03188
03192 inline const XnGrayscale8Pixel* GetGrayscale8ImageMap() const
03193 {
03194 return xnGetGrayscale8ImageMap(GetHandle());
03195 }
03196
03200 inline const XnGrayscale16Pixel* GetGrayscale16ImageMap() const
03201 {
03202 return xnGetGrayscale16ImageMap(GetHandle());
03203 }
03204
03208 inline const XnUInt8* GetImageMap() const
03209 {
03210 return xnGetImageMap(GetHandle());
03211 }
03212
03216 inline XnBool IsPixelFormatSupported(XnPixelFormat Format) const
03217 {
03218 return xnIsPixelFormatSupported(GetHandle(), Format);
03219 }
03220
03224 inline XnStatus SetPixelFormat(XnPixelFormat Format)
03225 {
03226 return xnSetPixelFormat(GetHandle(), Format);
03227 }
03228
03232 inline XnPixelFormat GetPixelFormat() const
03233 {
03234 return xnGetPixelFormat(GetHandle());
03235 }
03236
03240 inline XnStatus RegisterToPixelFormatChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
03241 {
03242 return _RegisterToStateChange(xnRegisterToPixelFormatChange, GetHandle(), handler, pCookie, hCallback);
03243 }
03244
03248 inline void UnregisterFromPixelFormatChange(XnCallbackHandle hCallback)
03249 {
03250 _UnregisterFromStateChange(xnUnregisterFromPixelFormatChange, GetHandle(), hCallback);
03251 }
03252 };
03253
03258 class MockImageGenerator : public ImageGenerator
03259 {
03260 public:
03266 inline MockImageGenerator(XnNodeHandle hNode = NULL) : ImageGenerator(hNode) {}
03267 inline MockImageGenerator(const NodeWrapper& other) : ImageGenerator(other) {}
03268
03275 XnStatus Create(Context& context, const XnChar* strName = NULL);
03276
03283 XnStatus CreateBasedOn(ImageGenerator& other, const XnChar* strName = NULL);
03284
03288 inline XnStatus SetData(XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize, const XnUInt8* pImageMap)
03289 {
03290 return xnMockImageSetData(GetHandle(), nFrameID, nTimestamp, nDataSize, pImageMap);
03291 }
03292
03300 inline XnStatus SetData(const ImageMetaData& imageMD, XnUInt32 nFrameID, XnUInt64 nTimestamp)
03301 {
03302 return SetData(nFrameID, nTimestamp, imageMD.DataSize(), imageMD.Data());
03303 }
03304
03310 inline XnStatus SetData(const ImageMetaData& imageMD)
03311 {
03312 return SetData(imageMD, imageMD.FrameID(), imageMD.Timestamp());
03313 }
03314 };
03315
03320 class IRGenerator : public MapGenerator
03321 {
03322 public:
03328 inline IRGenerator(XnNodeHandle hNode = NULL) : MapGenerator(hNode) {}
03329 inline IRGenerator(const NodeWrapper& other) : MapGenerator(other) {}
03330
03334 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL);
03335
03339 inline void GetMetaData(IRMetaData& metaData) const
03340 {
03341 xnGetIRMetaData(GetHandle(), metaData.GetUnderlying());
03342 }
03343
03347 inline const XnIRPixel* GetIRMap() const
03348 {
03349 return xnGetIRMap(GetHandle());
03350 }
03351 };
03352
03357 class MockIRGenerator : public IRGenerator
03358 {
03359 public:
03365 inline MockIRGenerator(XnNodeHandle hNode = NULL) : IRGenerator(hNode) {}
03366 inline MockIRGenerator(const NodeWrapper& other) : IRGenerator(other) {}
03367
03374 XnStatus Create(Context& context, const XnChar* strName = NULL);
03381 XnStatus CreateBasedOn(IRGenerator& other, const XnChar* strName = NULL);
03382
03386 inline XnStatus SetData(XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize, const XnIRPixel* pIRMap)
03387 {
03388 return xnMockIRSetData(GetHandle(), nFrameID, nTimestamp, nDataSize, pIRMap);
03389 }
03390
03398 inline XnStatus SetData(const IRMetaData& irMD, XnUInt32 nFrameID, XnUInt64 nTimestamp)
03399 {
03400 return SetData(nFrameID, nTimestamp, irMD.DataSize(), irMD.Data());
03401 }
03402
03408 inline XnStatus SetData(const IRMetaData& irMD)
03409 {
03410 return SetData(irMD, irMD.FrameID(), irMD.Timestamp());
03411 }
03412 };
03413
03418 class GestureGenerator : public Generator
03419 {
03420 public:
03426 inline GestureGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {}
03427 inline GestureGenerator(const NodeWrapper& other) : Generator(other) {}
03428
03432 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL);
03433
03437 inline XnStatus AddGesture(const XnChar* strGesture, XnBoundingBox3D* pArea)
03438 {
03439 return xnAddGesture(GetHandle(), strGesture, pArea);
03440 }
03441
03445 inline XnStatus RemoveGesture(const XnChar* strGesture)
03446 {
03447 return xnRemoveGesture(GetHandle(), strGesture);
03448 }
03449
03453 inline XnStatus GetActiveGestures(XnChar*& astrGestures, XnUInt16& nGestures) const
03454 {
03455 return xnGetActiveGestures(GetHandle(), &astrGestures, &nGestures);
03456 }
03457
03461 inline XnStatus GetAllActiveGestures(XnChar** astrGestures, XnUInt32 nNameLength, XnUInt16& nGestures) const
03462 {
03463 return xnGetAllActiveGestures(GetHandle(), astrGestures, nNameLength, &nGestures);
03464 }
03465
03469 inline XnStatus EnumerateGestures(XnChar*& astrGestures, XnUInt16& nGestures) const
03470 {
03471 return xnEnumerateGestures(GetHandle(), &astrGestures, &nGestures);
03472 }
03476 inline XnStatus EnumerateAllGestures(XnChar** astrGestures, XnUInt32 nNameLength, XnUInt16& nGestures) const
03477 {
03478 return xnEnumerateAllGestures(GetHandle(), astrGestures, nNameLength, &nGestures);
03479 }
03480
03484 inline XnBool IsGestureAvailable(const XnChar* strGesture) const
03485 {
03486 return xnIsGestureAvailable(GetHandle(), strGesture);
03487 }
03488
03492 inline XnBool IsGestureProgressSupported(const XnChar* strGesture) const
03493 {
03494 return xnIsGestureProgressSupported(GetHandle(), strGesture);
03495 }
03496
03506 typedef void (XN_CALLBACK_TYPE* GestureRecognized)(GestureGenerator& generator, const XnChar* strGesture, const XnPoint3D* pIDPosition, const XnPoint3D* pEndPosition, void* pCookie);
03516 typedef void (XN_CALLBACK_TYPE* GestureProgress)(GestureGenerator& generator, const XnChar* strGesture, const XnPoint3D* pPosition, XnFloat fProgress, void* pCookie);
03517
03521 XnStatus RegisterGestureCallbacks(GestureRecognized RecognizedCB, GestureProgress ProgressCB, void* pCookie, XnCallbackHandle& hCallback)
03522 {
03523 XnStatus nRetVal = XN_STATUS_OK;
03524
03525 GestureCookie* pGestureCookie;
03526 XN_VALIDATE_ALLOC(pGestureCookie, GestureCookie);
03527 pGestureCookie->recognizedHandler = RecognizedCB;
03528 pGestureCookie->progressHandler = ProgressCB;
03529 pGestureCookie->pUserCookie = pCookie;
03530
03531 nRetVal = xnRegisterGestureCallbacks(GetHandle(), GestureRecognizedCallback, GestureProgressCallback, pGestureCookie, &pGestureCookie->hCallback);
03532 if (nRetVal != XN_STATUS_OK)
03533 {
03534 xnOSFree(pGestureCookie);
03535 return (nRetVal);
03536 }
03537
03538 hCallback = pGestureCookie;
03539
03540 return (XN_STATUS_OK);
03541 }
03542
03546 inline void UnregisterGestureCallbacks(XnCallbackHandle hCallback)
03547 {
03548 GestureCookie* pGestureCookie = (GestureCookie*)hCallback;
03549 xnUnregisterGestureCallbacks(GetHandle(), pGestureCookie->hCallback);
03550 xnOSFree(pGestureCookie);
03551 }
03552
03556 inline XnStatus RegisterToGestureChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
03557 {
03558 return _RegisterToStateChange(xnRegisterToGestureChange, GetHandle(), handler, pCookie, hCallback);
03559 }
03560
03564 inline void UnregisterFromGestureChange(XnCallbackHandle hCallback)
03565 {
03566 _UnregisterFromStateChange(xnUnregisterFromGestureChange, GetHandle(), hCallback);
03567 }
03568
03577 typedef void (XN_CALLBACK_TYPE* GestureIntermediateStageCompleted)(GestureGenerator& generator, const XnChar* strGesture, const XnPoint3D* pPosition, void* pCookie);
03581 XnStatus RegisterToGestureIntermediateStageCompleted(GestureIntermediateStageCompleted handler, void* pCookie, XnCallbackHandle& hCallback)
03582 {
03583 XnStatus nRetVal = XN_STATUS_OK;
03584
03585 GestureIntermediateStageCompletedCookie* pGestureCookie;
03586 XN_VALIDATE_ALLOC(pGestureCookie, GestureIntermediateStageCompletedCookie);
03587 pGestureCookie->handler = handler;
03588 pGestureCookie->pUserCookie = pCookie;
03589
03590 nRetVal = xnRegisterToGestureIntermediateStageCompleted(GetHandle(), GestureIntermediateStageCompletedCallback, pGestureCookie, &pGestureCookie->hCallback);
03591 if (nRetVal != XN_STATUS_OK)
03592 {
03593 xnOSFree(pGestureCookie);
03594 return (nRetVal);
03595 }
03596
03597 hCallback = pGestureCookie;
03598
03599 return (XN_STATUS_OK);
03600 }
03604 inline void UnregisterFromGestureIntermediateStageCompleted(XnCallbackHandle hCallback)
03605 {
03606 GestureIntermediateStageCompletedCookie* pGestureCookie = (GestureIntermediateStageCompletedCookie*)hCallback;
03607 xnUnregisterFromGestureIntermediateStageCompleted(GetHandle(), pGestureCookie->hCallback);
03608 xnOSFree(pGestureCookie);
03609 }
03610
03619 typedef void (XN_CALLBACK_TYPE* GestureReadyForNextIntermediateStage)(GestureGenerator& generator, const XnChar* strGesture, const XnPoint3D* pPosition, void* pCookie);
03623 XnStatus RegisterToGestureReadyForNextIntermediateStage(GestureReadyForNextIntermediateStage handler, void* pCookie, XnCallbackHandle& hCallback)
03624 {
03625 XnStatus nRetVal = XN_STATUS_OK;
03626
03627 GestureReadyForNextIntermediateStageCookie* pGestureCookie;
03628 XN_VALIDATE_ALLOC(pGestureCookie, GestureReadyForNextIntermediateStageCookie);
03629 pGestureCookie->handler = handler;
03630 pGestureCookie->pUserCookie = pCookie;
03631
03632 nRetVal = xnRegisterToGestureReadyForNextIntermediateStage(GetHandle(), GestureReadyForNextIntermediateStageCallback, pGestureCookie, &pGestureCookie->hCallback);
03633 if (nRetVal != XN_STATUS_OK)
03634 {
03635 xnOSFree(pGestureCookie);
03636 return (nRetVal);
03637 }
03638
03639 hCallback = pGestureCookie;
03640
03641 return (XN_STATUS_OK);
03642 }
03643
03647 inline void UnregisterFromGestureReadyForNextIntermediateStageCallbacks(XnCallbackHandle hCallback)
03648 {
03649 GestureReadyForNextIntermediateStageCookie* pGestureCookie = (GestureReadyForNextIntermediateStageCookie*)hCallback;
03650 xnUnregisterFromGestureReadyForNextIntermediateStage(GetHandle(), pGestureCookie->hCallback);
03651 xnOSFree(pGestureCookie);
03652 }
03653
03654 private:
03655 typedef struct GestureCookie
03656 {
03657 GestureRecognized recognizedHandler;
03658 GestureProgress progressHandler;
03659 void* pUserCookie;
03660 XnCallbackHandle hCallback;
03661 } GestureCookie;
03662
03663 static void XN_CALLBACK_TYPE GestureRecognizedCallback(XnNodeHandle hNode, const XnChar* strGesture, const XnPoint3D* pIDPosition, const XnPoint3D* pEndPosition, void* pCookie)
03664 {
03665 GestureCookie* pGestureCookie = (GestureCookie*)pCookie;
03666 GestureGenerator gen(hNode);
03667 if (pGestureCookie->recognizedHandler != NULL)
03668 {
03669 pGestureCookie->recognizedHandler(gen, strGesture, pIDPosition, pEndPosition, pGestureCookie->pUserCookie);
03670 }
03671 }
03672
03673 static void XN_CALLBACK_TYPE GestureProgressCallback(XnNodeHandle hNode, const XnChar* strGesture, const XnPoint3D* pPosition, XnFloat fProgress, void* pCookie)
03674 {
03675 GestureCookie* pGestureCookie = (GestureCookie*)pCookie;
03676 GestureGenerator gen(hNode);
03677 if (pGestureCookie->progressHandler != NULL)
03678 {
03679 pGestureCookie->progressHandler(gen, strGesture, pPosition, fProgress, pGestureCookie->pUserCookie);
03680 }
03681 }
03682
03683 typedef struct GestureIntermediateStageCompletedCookie
03684 {
03685 GestureIntermediateStageCompleted handler;
03686 void* pUserCookie;
03687 XnCallbackHandle hCallback;
03688 } GestureIntermediateStageCompletedCookie;
03689
03690 static void XN_CALLBACK_TYPE GestureIntermediateStageCompletedCallback(XnNodeHandle hNode, const XnChar* strGesture, const XnPoint3D* pPosition, void* pCookie)
03691 {
03692 GestureIntermediateStageCompletedCookie* pGestureCookie = (GestureIntermediateStageCompletedCookie*)pCookie;
03693 GestureGenerator gen(hNode);
03694 if (pGestureCookie->handler != NULL)
03695 {
03696 pGestureCookie->handler(gen, strGesture, pPosition, pGestureCookie->pUserCookie);
03697 }
03698 }
03699
03700 typedef struct GestureReadyForNextIntermediateStageCookie
03701 {
03702 GestureReadyForNextIntermediateStage handler;
03703 void* pUserCookie;
03704 XnCallbackHandle hCallback;
03705 } GestureReadyForNextIntermediateStageCookie;
03706
03707 static void XN_CALLBACK_TYPE GestureReadyForNextIntermediateStageCallback(XnNodeHandle hNode, const XnChar* strGesture, const XnPoint3D* pPosition, void* pCookie)
03708 {
03709 GestureReadyForNextIntermediateStageCookie* pGestureCookie = (GestureReadyForNextIntermediateStageCookie*)pCookie;
03710 GestureGenerator gen(hNode);
03711 if (pGestureCookie->handler != NULL)
03712 {
03713 pGestureCookie->handler(gen, strGesture, pPosition, pGestureCookie->pUserCookie);
03714 }
03715 }
03716 };
03717
03722 class SceneAnalyzer : public MapGenerator
03723 {
03724 public:
03730 inline SceneAnalyzer(XnNodeHandle hNode = NULL) : MapGenerator(hNode) {}
03731 inline SceneAnalyzer(const NodeWrapper& other) : MapGenerator(other) {}
03732
03736 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL);
03737
03741 inline void GetMetaData(SceneMetaData& metaData) const
03742 {
03743 xnGetSceneMetaData(GetHandle(), metaData.GetUnderlying());
03744 }
03745
03749 inline const XnLabel* GetLabelMap() const
03750 {
03751 return xnGetLabelMap(GetHandle());
03752 }
03753
03757 inline XnStatus GetFloor(XnPlane3D& Plane) const
03758 {
03759 return xnGetFloor(GetHandle(), &Plane);
03760 }
03761 };
03762
03767 class HandTouchingFOVEdgeCapability : public Capability
03768 {
03769 public:
03775 inline HandTouchingFOVEdgeCapability(XnNodeHandle hNode) : Capability(hNode) {}
03776 HandTouchingFOVEdgeCapability(const NodeWrapper& node) : Capability(node) {}
03777
03788 typedef void (XN_CALLBACK_TYPE* HandTouchingFOVEdge)(HandTouchingFOVEdgeCapability& touchingfov, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, XnDirection eDir, void* pCookie);
03792 inline XnStatus RegisterToHandTouchingFOVEdge(HandTouchingFOVEdge handler, void* pCookie, XnCallbackHandle& hCallback)
03793 {
03794 XnStatus nRetVal = XN_STATUS_OK;
03795
03796 HandTouchingFOVEdgeCookie* pHandCookie;
03797 XN_VALIDATE_ALLOC(pHandCookie, HandTouchingFOVEdgeCookie);
03798 pHandCookie->handler = handler;
03799 pHandCookie->pUserCookie = pCookie;
03800
03801 nRetVal = xnRegisterToHandTouchingFOVEdge(GetHandle(), HandTouchingFOVEdgeCB, pHandCookie, &pHandCookie->hCallback);
03802 if (nRetVal != XN_STATUS_OK)
03803 {
03804 xnOSFree(pHandCookie);
03805 return (nRetVal);
03806 }
03807
03808 hCallback = pHandCookie;
03809
03810 return (XN_STATUS_OK);
03811 }
03812
03816 inline void UnregisterFromHandTouchingFOVEdge(XnCallbackHandle hCallback)
03817 {
03818 HandTouchingFOVEdgeCookie* pHandCookie = (HandTouchingFOVEdgeCookie*)hCallback;
03819 xnUnregisterFromHandTouchingFOVEdge(GetHandle(), pHandCookie->hCallback);
03820 xnOSFree(pHandCookie);
03821 }
03822 private:
03823 typedef struct HandTouchingFOVEdgeCookie
03824 {
03825 HandTouchingFOVEdge handler;
03826 void* pUserCookie;
03827 XnCallbackHandle hCallback;
03828 } HandTouchingFOVEdgeCookie;
03829
03830 static void XN_CALLBACK_TYPE HandTouchingFOVEdgeCB(XnNodeHandle hNode, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, XnDirection eDir, void* pCookie)
03831 {
03832 HandTouchingFOVEdgeCookie* pHandCookie = (HandTouchingFOVEdgeCookie*)pCookie;
03833 HandTouchingFOVEdgeCapability cap(hNode);
03834 if (pHandCookie->handler != NULL)
03835 {
03836 pHandCookie->handler(cap, user, pPosition, fTime, eDir, pHandCookie->pUserCookie);
03837 }
03838 }
03839
03840 };
03845 class HandsGenerator : public Generator
03846 {
03847 public:
03853 inline HandsGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {}
03854 inline HandsGenerator(const NodeWrapper& other) : Generator(other) {}
03855
03859 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL);
03860
03870 typedef void (XN_CALLBACK_TYPE* HandCreate)(HandsGenerator& generator, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, void* pCookie);
03880 typedef void (XN_CALLBACK_TYPE* HandUpdate)(HandsGenerator& generator, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, void* pCookie);
03889 typedef void (XN_CALLBACK_TYPE* HandDestroy)(HandsGenerator& generator, XnUserID user, XnFloat fTime, void* pCookie);
03890
03894 inline XnStatus RegisterHandCallbacks(HandCreate CreateCB, HandUpdate UpdateCB, HandDestroy DestroyCB, void* pCookie, XnCallbackHandle& hCallback)
03895 {
03896 XnStatus nRetVal = XN_STATUS_OK;
03897
03898 HandCookie* pHandCookie;
03899 XN_VALIDATE_ALLOC(pHandCookie, HandCookie);
03900 pHandCookie->createHandler = CreateCB;
03901 pHandCookie->updateHandler = UpdateCB;
03902 pHandCookie->destroyHandler = DestroyCB;
03903 pHandCookie->pUserCookie = pCookie;
03904
03905 nRetVal = xnRegisterHandCallbacks(GetHandle(), HandCreateCB, HandUpdateCB, HandDestroyCB, pHandCookie, &pHandCookie->hCallback);
03906 if (nRetVal != XN_STATUS_OK)
03907 {
03908 xnOSFree(pHandCookie);
03909 return (nRetVal);
03910 }
03911
03912 hCallback = pHandCookie;
03913
03914 return (XN_STATUS_OK);
03915 }
03916
03920 inline void UnregisterHandCallbacks(XnCallbackHandle hCallback)
03921 {
03922 HandCookie* pHandCookie = (HandCookie*)hCallback;
03923 xnUnregisterHandCallbacks(GetHandle(), pHandCookie->hCallback);
03924 xnOSFree(pHandCookie);
03925 }
03926
03930 inline XnStatus StopTracking(XnUserID user)
03931 {
03932 return xnStopTracking(GetHandle(), user);
03933 }
03934
03938 inline XnStatus StopTrackingAll()
03939 {
03940 return xnStopTrackingAll(GetHandle());
03941 }
03942
03946 inline XnStatus StartTracking(const XnPoint3D& ptPosition)
03947 {
03948 return xnStartTracking(GetHandle(), &ptPosition);
03949 }
03950
03954 inline XnStatus SetSmoothing(XnFloat fSmoothingFactor)
03955 {
03956 return xnSetTrackingSmoothing(GetHandle(), fSmoothingFactor);
03957 }
03958
03964 inline const HandTouchingFOVEdgeCapability GetHandTouchingFOVEdgeCap() const
03965 {
03966 return HandTouchingFOVEdgeCapability(GetHandle());
03967 }
03968
03974 inline HandTouchingFOVEdgeCapability GetHandTouchingFOVEdgeCap()
03975 {
03976 return HandTouchingFOVEdgeCapability(GetHandle());
03977 }
03978
03979 private:
03980 typedef struct HandCookie
03981 {
03982 HandCreate createHandler;
03983 HandUpdate updateHandler;
03984 HandDestroy destroyHandler;
03985 void* pUserCookie;
03986 XnCallbackHandle hCallback;
03987 } HandCookie;
03988
03989 static void XN_CALLBACK_TYPE HandCreateCB(XnNodeHandle hNode, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, void* pCookie)
03990 {
03991 HandCookie* pHandCookie = (HandCookie*)pCookie;
03992 HandsGenerator gen(hNode);
03993 if (pHandCookie->createHandler != NULL)
03994 {
03995 pHandCookie->createHandler(gen, user, pPosition, fTime, pHandCookie->pUserCookie);
03996 }
03997 }
03998 static void XN_CALLBACK_TYPE HandUpdateCB(XnNodeHandle hNode, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, void* pCookie)
03999 {
04000 HandCookie* pHandCookie = (HandCookie*)pCookie;
04001 HandsGenerator gen(hNode);
04002 if (pHandCookie->updateHandler != NULL)
04003 {
04004 pHandCookie->updateHandler(gen, user, pPosition, fTime, pHandCookie->pUserCookie);
04005 }
04006 }
04007 static void XN_CALLBACK_TYPE HandDestroyCB(XnNodeHandle hNode, XnUserID user, XnFloat fTime, void* pCookie)
04008 {
04009 HandCookie* pHandCookie = (HandCookie*)pCookie;
04010 HandsGenerator gen(hNode);
04011 if (pHandCookie->destroyHandler != NULL)
04012 {
04013 pHandCookie->destroyHandler(gen, user, fTime, pHandCookie->pUserCookie);
04014 }
04015 }
04016 };
04017
04022 class SkeletonCapability : public Capability
04023 {
04024 public:
04030 inline SkeletonCapability(XnNodeHandle hNode) : Capability(hNode) {}
04031 SkeletonCapability(const NodeWrapper& node) : Capability(node) {}
04032
04036 inline XnBool IsJointAvailable(XnSkeletonJoint eJoint) const
04037 {
04038 return xnIsJointAvailable(GetHandle(), eJoint);
04039 }
04040
04044 inline XnBool IsProfileAvailable(XnSkeletonProfile eProfile) const
04045 {
04046 return xnIsProfileAvailable(GetHandle(), eProfile);
04047 }
04048
04052 inline XnStatus SetSkeletonProfile(XnSkeletonProfile eProfile)
04053 {
04054 return xnSetSkeletonProfile(GetHandle(), eProfile);
04055 }
04056
04060 inline XnStatus SetJointActive(XnSkeletonJoint eJoint, XnBool bState)
04061 {
04062 return xnSetJointActive(GetHandle(), eJoint, bState);
04063 }
04064
04068 XN_API_DEPRECATED("Use the version with one argument")
04069 inline XnBool IsJointActive(XnSkeletonJoint eJoint, XnBool ) const
04070 {
04071 return xnIsJointActive(GetHandle(), eJoint);
04072 }
04073
04077 inline XnBool IsJointActive(XnSkeletonJoint eJoint) const
04078 {
04079 return xnIsJointActive(GetHandle(), eJoint);
04080 }
04081
04085 inline XnStatus RegisterToJointConfigurationChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
04086 {
04087 return _RegisterToStateChange(xnRegisterToJointConfigurationChange, GetHandle(), handler, pCookie, hCallback);
04088 }
04089
04093 inline void UnregisterFromJointConfigurationChange(XnCallbackHandle hCallback)
04094 {
04095 _UnregisterFromStateChange(xnUnregisterFromJointConfigurationChange, GetHandle(), hCallback);
04096 }
04097
04101 inline XnStatus EnumerateActiveJoints(XnSkeletonJoint* pJoints, XnUInt16& nJoints) const
04102 {
04103 return xnEnumerateActiveJoints(GetHandle(), pJoints, &nJoints);
04104 }
04105
04109 inline XnStatus GetSkeletonJoint(XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointTransformation& Joint) const
04110 {
04111 return xnGetSkeletonJoint(GetHandle(), user, eJoint, &Joint);
04112 }
04113
04117 inline XnStatus GetSkeletonJointPosition(XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointPosition& Joint) const
04118 {
04119 return xnGetSkeletonJointPosition(GetHandle(), user, eJoint, &Joint);
04120 }
04121
04125 inline XnStatus GetSkeletonJointOrientation(XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointOrientation& Joint) const
04126 {
04127 return xnGetSkeletonJointOrientation(GetHandle(), user, eJoint, &Joint);
04128 }
04129
04133 inline XnBool IsTracking(XnUserID user) const
04134 {
04135 return xnIsSkeletonTracking(GetHandle(), user);
04136 }
04137
04141 inline XnBool IsCalibrated(XnUserID user) const
04142 {
04143
04144 return xnIsSkeletonCalibrated(GetHandle(), user);
04145 }
04146
04150 inline XnBool IsCalibrating(XnUserID user) const
04151 {
04152 return xnIsSkeletonCalibrating(GetHandle(), user);
04153 }
04154
04158 inline XnStatus RequestCalibration(XnUserID user, XnBool bForce)
04159 {
04160 return xnRequestSkeletonCalibration(GetHandle(), user, bForce);
04161 }
04162
04166 inline XnStatus AbortCalibration(XnUserID user)
04167 {
04168 return xnAbortSkeletonCalibration(GetHandle(), user);
04169 }
04170
04174 inline XnStatus SaveCalibrationDataToFile(XnUserID user, const XnChar* strFileName)
04175 {
04176 return xnSaveSkeletonCalibrationDataToFile(GetHandle(), user, strFileName);
04177 }
04178
04182 inline XnStatus LoadCalibrationDataFromFile(XnUserID user, const XnChar* strFileName)
04183 {
04184 return xnLoadSkeletonCalibrationDataFromFile(GetHandle(), user, strFileName);
04185 }
04186
04190 inline XnStatus SaveCalibrationData(XnUserID user, XnUInt32 nSlot)
04191 {
04192 return xnSaveSkeletonCalibrationData(GetHandle(), user, nSlot);
04193 }
04194
04198 inline XnStatus LoadCalibrationData(XnUserID user, XnUInt32 nSlot)
04199 {
04200 return xnLoadSkeletonCalibrationData(GetHandle(), user, nSlot);
04201 }
04202
04206 inline XnStatus ClearCalibrationData(XnUInt32 nSlot)
04207 {
04208 return xnClearSkeletonCalibrationData(GetHandle(), nSlot);
04209 }
04210
04214 inline XnBool IsCalibrationData(XnUInt32 nSlot) const
04215 {
04216 return xnIsSkeletonCalibrationData(GetHandle(), nSlot);
04217 }
04218
04222 inline XnStatus StartTracking(XnUserID user)
04223 {
04224 return xnStartSkeletonTracking(GetHandle(), user);
04225 }
04226
04230 inline XnStatus StopTracking(XnUserID user)
04231 {
04232 return xnStopSkeletonTracking(GetHandle(), user);
04233 }
04234
04238 inline XnStatus Reset(XnUserID user)
04239 {
04240 return xnResetSkeleton(GetHandle(), user);
04241 }
04242
04246 inline XnBool NeedPoseForCalibration() const
04247 {
04248 return xnNeedPoseForSkeletonCalibration(GetHandle());
04249 }
04250
04254 inline XnStatus GetCalibrationPose(XnChar* strPose) const
04255 {
04256 return xnGetSkeletonCalibrationPose(GetHandle(), strPose);
04257 }
04258
04262 inline XnStatus SetSmoothing(XnFloat fSmoothingFactor)
04263 {
04264 return xnSetSkeletonSmoothing(GetHandle(), fSmoothingFactor);
04265 }
04266
04274 typedef void (XN_CALLBACK_TYPE* CalibrationStart)(SkeletonCapability& skeleton, XnUserID user, void* pCookie);
04283 typedef void (XN_CALLBACK_TYPE* CalibrationEnd)(SkeletonCapability& skeleton, XnUserID user, XnBool bSuccess, void* pCookie);
04284
04288 inline XnStatus XN_API_DEPRECATED("Please use RegisterToCalibrationStart/Complete") RegisterCalibrationCallbacks(CalibrationStart CalibrationStartCB, CalibrationEnd CalibrationEndCB, void* pCookie, XnCallbackHandle& hCallback)
04289 {
04290 XnStatus nRetVal = XN_STATUS_OK;
04291
04292 SkeletonCookie* pSkeletonCookie;
04293 XN_VALIDATE_ALLOC(pSkeletonCookie, SkeletonCookie);
04294 pSkeletonCookie->startHandler = CalibrationStartCB;
04295 pSkeletonCookie->endHandler = CalibrationEndCB;
04296 pSkeletonCookie->pUserCookie = pCookie;
04297
04298 #pragma warning (push)
04299 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
04300 nRetVal = xnRegisterCalibrationCallbacks(GetHandle(), CalibrationStartBundleCallback, CalibrationEndBundleCallback, pSkeletonCookie, &pSkeletonCookie->hCallback);
04301 #pragma warning (pop)
04302 if (nRetVal != XN_STATUS_OK)
04303 {
04304 xnOSFree(pSkeletonCookie);
04305 return (nRetVal);
04306 }
04307
04308 hCallback = pSkeletonCookie;
04309
04310 return (XN_STATUS_OK);
04311 }
04312
04316 inline void XN_API_DEPRECATED("Please use UnregisterFromCalibrationStart/Complete") UnregisterCalibrationCallbacks(XnCallbackHandle hCallback)
04317 {
04318 SkeletonCookie* pSkeletonCookie = (SkeletonCookie*)hCallback;
04319 #pragma warning (push)
04320 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
04321 xnUnregisterCalibrationCallbacks(GetHandle(), pSkeletonCookie->hCallback);
04322 #pragma warning (pop)
04323 xnOSFree(pSkeletonCookie);
04324 }
04325
04329 inline XnStatus RegisterToCalibrationStart(CalibrationStart handler, void* pCookie, XnCallbackHandle& hCallback)
04330 {
04331 XnStatus nRetVal = XN_STATUS_OK;
04332 CalibrationStartCookie* pCalibrationCookie;
04333 XN_VALIDATE_ALLOC(pCalibrationCookie, CalibrationStartCookie);
04334 pCalibrationCookie->handler = handler;
04335 pCalibrationCookie->pUserCookie = pCookie;
04336 nRetVal = xnRegisterToCalibrationStart(GetHandle(), CalibrationStartCallback, pCalibrationCookie, &pCalibrationCookie->hCallback);
04337 if (nRetVal != XN_STATUS_OK)
04338 {
04339 xnOSFree(pCalibrationCookie);
04340 return nRetVal;
04341 }
04342 hCallback = pCalibrationCookie;
04343 return XN_STATUS_OK;
04344 }
04348 inline XnStatus UnregisterFromCalibrationStart(XnCallbackHandle hCallback)
04349 {
04350 CalibrationStartCookie* pCalibrationCookie = (CalibrationStartCookie*)hCallback;
04351 xnUnregisterFromCalibrationStart(GetHandle(), pCalibrationCookie->hCallback);
04352 xnOSFree(pCalibrationCookie);
04353 return XN_STATUS_OK;
04354 }
04355
04364 typedef void (XN_CALLBACK_TYPE* CalibrationInProgress)(SkeletonCapability& skeleton, XnUserID user, XnCalibrationStatus calibrationError, void* pCookie);
04365
04369 inline XnStatus RegisterToCalibrationInProgress(CalibrationInProgress handler, void* pCookie, XnCallbackHandle& hCallback)
04370 {
04371 XnStatus nRetVal = XN_STATUS_OK;
04372
04373 CalibrationInProgressCookie* pSkeletonCookie;
04374 XN_VALIDATE_ALLOC(pSkeletonCookie, CalibrationInProgressCookie);
04375 pSkeletonCookie->handler = handler;
04376 pSkeletonCookie->pUserCookie = pCookie;
04377
04378 nRetVal = xnRegisterToCalibrationInProgress(GetHandle(), CalibrationInProgressCallback, pSkeletonCookie, &pSkeletonCookie->hCallback);
04379 if (nRetVal != XN_STATUS_OK)
04380 {
04381 xnOSFree(pSkeletonCookie);
04382 return (nRetVal);
04383 }
04384
04385 hCallback = pSkeletonCookie;
04386
04387 return (XN_STATUS_OK);
04388 }
04389
04393 inline void UnregisterFromCalibrationInProgress(XnCallbackHandle hCallback)
04394 {
04395 CalibrationInProgressCookie* pSkeletonCookie = (CalibrationInProgressCookie*)hCallback;
04396 xnUnregisterFromCalibrationInProgress(GetHandle(), pSkeletonCookie->hCallback);
04397 xnOSFree(pSkeletonCookie);
04398 }
04399
04408 typedef void (XN_CALLBACK_TYPE* CalibrationComplete)(SkeletonCapability& skeleton, XnUserID user, XnCalibrationStatus calibrationError, void* pCookie);
04412 inline XnStatus RegisterToCalibrationComplete(CalibrationComplete handler, void* pCookie, XnCallbackHandle& hCallback)
04413 {
04414 XnStatus nRetVal = XN_STATUS_OK;
04415
04416 CalibrationCompleteCookie* pSkeletonCookie;
04417 XN_VALIDATE_ALLOC(pSkeletonCookie, CalibrationCompleteCookie);
04418 pSkeletonCookie->handler = handler;
04419 pSkeletonCookie->pUserCookie = pCookie;
04420
04421 nRetVal = xnRegisterToCalibrationComplete(GetHandle(), CalibrationCompleteCallback, pSkeletonCookie, &pSkeletonCookie->hCallback);
04422 if (nRetVal != XN_STATUS_OK)
04423 {
04424 xnOSFree(pSkeletonCookie);
04425 return (nRetVal);
04426 }
04427
04428 hCallback = pSkeletonCookie;
04429
04430 return (XN_STATUS_OK);
04431 }
04432
04436 inline void UnregisterFromCalibrationComplete(XnCallbackHandle hCallback)
04437 {
04438 CalibrationCompleteCookie* pSkeletonCookie = (CalibrationCompleteCookie*)hCallback;
04439 xnUnregisterFromCalibrationComplete(GetHandle(), pSkeletonCookie->hCallback);
04440 xnOSFree(pSkeletonCookie);
04441 }
04442 private:
04443 typedef struct SkeletonCookie
04444 {
04445 CalibrationStart startHandler;
04446 CalibrationEnd endHandler;
04447 void* pUserCookie;
04448 XnCallbackHandle hCallback;
04449 } SkeletonCookie;
04450
04451 static void XN_CALLBACK_TYPE CalibrationStartBundleCallback(XnNodeHandle hNode, XnUserID user, void* pCookie)
04452 {
04453 SkeletonCookie* pSkeletonCookie = (SkeletonCookie*)pCookie;
04454 SkeletonCapability cap(hNode);
04455 if (pSkeletonCookie->startHandler != NULL)
04456 {
04457 pSkeletonCookie->startHandler(cap, user, pSkeletonCookie->pUserCookie);
04458 }
04459 }
04460
04461 static void XN_CALLBACK_TYPE CalibrationEndBundleCallback(XnNodeHandle hNode, XnUserID user, XnBool bSuccess, void* pCookie)
04462 {
04463 SkeletonCookie* pSkeletonCookie = (SkeletonCookie*)pCookie;
04464 SkeletonCapability cap(hNode);
04465 if (pSkeletonCookie->endHandler != NULL)
04466 {
04467 pSkeletonCookie->endHandler(cap, user, bSuccess, pSkeletonCookie->pUserCookie);
04468 }
04469 }
04470 typedef struct CalibrationStartCookie
04471 {
04472 CalibrationStart handler;
04473 void* pUserCookie;
04474 XnCallbackHandle hCallback;
04475 } CalibrationStartCookie;
04476
04477 static void XN_CALLBACK_TYPE CalibrationStartCallback(XnNodeHandle hNode, XnUserID user, void* pCookie)
04478 {
04479 CalibrationStartCookie* pCalibrationCookie = (CalibrationStartCookie*)pCookie;
04480 SkeletonCapability cap(hNode);
04481 if (pCalibrationCookie->handler != NULL)
04482 {
04483 pCalibrationCookie->handler(cap, user, pCalibrationCookie->pUserCookie);
04484 }
04485 }
04486 typedef struct CalibrationInProgressCookie
04487 {
04488 CalibrationInProgress handler;
04489 void* pUserCookie;
04490 XnCallbackHandle hCallback;
04491 } CalibrationInProgressCookie;
04492
04493 static void XN_CALLBACK_TYPE CalibrationInProgressCallback(XnNodeHandle hNode, XnUserID user, XnCalibrationStatus calibrationError, void* pCookie)
04494 {
04495 CalibrationInProgressCookie* pSkeletonCookie = (CalibrationInProgressCookie*)pCookie;
04496 SkeletonCapability cap(hNode);
04497 if (pSkeletonCookie->handler != NULL)
04498 {
04499 pSkeletonCookie->handler(cap, user, calibrationError, pSkeletonCookie->pUserCookie);
04500 }
04501 }
04502
04503 typedef struct CalibrationCompleteCookie
04504 {
04505 CalibrationComplete handler;
04506 void* pUserCookie;
04507 XnCallbackHandle hCallback;
04508 } CalibrationCompleteCookie;
04509
04510 static void XN_CALLBACK_TYPE CalibrationCompleteCallback(XnNodeHandle hNode, XnUserID user, XnCalibrationStatus calibrationError, void* pCookie)
04511 {
04512 CalibrationCompleteCookie* pSkeletonCookie = (CalibrationCompleteCookie*)pCookie;
04513 SkeletonCapability cap(hNode);
04514 if (pSkeletonCookie->handler != NULL)
04515 {
04516 pSkeletonCookie->handler(cap, user, calibrationError, pSkeletonCookie->pUserCookie);
04517 }
04518 }
04519 };
04520
04525 class PoseDetectionCapability : public Capability
04526 {
04527 public:
04533 inline PoseDetectionCapability(XnNodeHandle hNode) : Capability(hNode) {}
04534 PoseDetectionCapability(const NodeWrapper& node) : Capability(node) {}
04535
04544 typedef void (XN_CALLBACK_TYPE* PoseDetection)(PoseDetectionCapability& pose, const XnChar* strPose, XnUserID user, void* pCookie);
04545
04549 inline XnUInt32 GetNumberOfPoses() const
04550 {
04551 return xnGetNumberOfPoses(GetHandle());
04552 }
04553
04557 inline XnStatus GetAvailablePoses(XnChar** pstrPoses, XnUInt32& nPoses) const
04558 {
04559 return xnGetAvailablePoses(GetHandle(), pstrPoses, &nPoses);
04560 }
04564 inline XnStatus GetAllAvailablePoses(XnChar** pstrPoses, XnUInt32 nNameLength, XnUInt32& nPoses) const
04565 {
04566 return xnGetAllAvailablePoses(GetHandle(), pstrPoses, nNameLength, &nPoses);
04567 }
04568
04572 inline XnStatus StartPoseDetection(const XnChar* strPose, XnUserID user)
04573 {
04574 return xnStartPoseDetection(GetHandle(), strPose, user);
04575 }
04576
04580 inline XnStatus StopPoseDetection(XnUserID user)
04581 {
04582 return xnStopPoseDetection(GetHandle(), user);
04583 }
04584
04588 inline XnStatus XN_API_DEPRECATED("Please use RegisterToPoseDetected/RegisterToOutOfPose instead") RegisterToPoseCallbacks(PoseDetection PoseStartCB, PoseDetection PoseEndCB, void* pCookie, XnCallbackHandle& hCallback)
04589 {
04590 XnStatus nRetVal = XN_STATUS_OK;
04591
04592 PoseCookie* pPoseCookie;
04593 XN_VALIDATE_ALLOC(pPoseCookie, PoseCookie);
04594 pPoseCookie->startHandler = PoseStartCB;
04595 pPoseCookie->endHandler = PoseEndCB;
04596 pPoseCookie->pPoseCookie = pCookie;
04597
04598 #pragma warning (push)
04599 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
04600 nRetVal = xnRegisterToPoseCallbacks(GetHandle(), PoseDetectionStartBundleCallback, PoseDetectionStartEndBundleCallback, pPoseCookie, &pPoseCookie->hCallback);
04601 #pragma warning (pop)
04602 if (nRetVal != XN_STATUS_OK)
04603 {
04604 xnOSFree(pPoseCookie);
04605 return (nRetVal);
04606 }
04607
04608 hCallback = pPoseCookie;
04609
04610 return (XN_STATUS_OK);
04611 }
04612
04616 inline void XN_API_DEPRECATED("Please use UnregisterFromPoseDetected/UnregisterFromOutOfPose instead") UnregisterFromPoseCallbacks(XnCallbackHandle hCallback)
04617 {
04618 PoseCookie* pPoseCookie = (PoseCookie*)hCallback;
04619 #pragma warning (push)
04620 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
04621 xnUnregisterFromPoseCallbacks(GetHandle(), pPoseCookie->hCallback);
04622 #pragma warning (pop)
04623 xnOSFree(pPoseCookie);
04624 }
04625
04629 inline XnStatus RegisterToPoseDetected(PoseDetection handler, void* pCookie, XnCallbackHandle& hCallback)
04630 {
04631 XnStatus nRetVal = XN_STATUS_OK;
04632 PoseDetectionCookie* pPoseCookie;
04633 XN_VALIDATE_ALLOC(pPoseCookie, PoseDetectionCookie);
04634 pPoseCookie->handler = handler;
04635 pPoseCookie->pPoseCookie = pCookie;
04636
04637 nRetVal = xnRegisterToPoseDetected(GetHandle(), PoseDetectionCallback, pPoseCookie, &pPoseCookie->hCallback);
04638 if (nRetVal != XN_STATUS_OK)
04639 {
04640 xnOSFree(pPoseCookie);
04641 return nRetVal;
04642 }
04643 hCallback = pPoseCookie;
04644 return XN_STATUS_OK;
04645 }
04649 inline XnStatus RegisterToOutOfPose(PoseDetection handler, void* pCookie, XnCallbackHandle& hCallback)
04650 {
04651 XnStatus nRetVal = XN_STATUS_OK;
04652 PoseDetectionCookie* pPoseCookie;
04653 XN_VALIDATE_ALLOC(pPoseCookie, PoseDetectionCookie);
04654 pPoseCookie->handler = handler;
04655 pPoseCookie->pPoseCookie = pCookie;
04656
04657 nRetVal = xnRegisterToOutOfPose(GetHandle(), PoseDetectionCallback, pPoseCookie, &pPoseCookie->hCallback);
04658 if (nRetVal != XN_STATUS_OK)
04659 {
04660 xnOSFree(pPoseCookie);
04661 return nRetVal;
04662 }
04663 hCallback = pPoseCookie;
04664 return XN_STATUS_OK;
04665 }
04669 inline void UnregisterFromPoseDetected(XnCallbackHandle hCallback)
04670 {
04671 PoseDetectionCookie* pPoseCookie = (PoseDetectionCookie*)hCallback;
04672 xnUnregisterFromPoseDetected(GetHandle(), pPoseCookie->hCallback);
04673 xnOSFree(pPoseCookie);
04674 }
04678 inline void UnregisterFromOutOfPose(XnCallbackHandle hCallback)
04679 {
04680 PoseDetectionCookie* pPoseCookie = (PoseDetectionCookie*)hCallback;
04681 xnUnregisterFromOutOfPose(GetHandle(), pPoseCookie->hCallback);
04682 xnOSFree(pPoseCookie);
04683 }
04684
04694 typedef void (XN_CALLBACK_TYPE* PoseInProgress)(PoseDetectionCapability& pose, const XnChar* strPose, XnUserID user, XnPoseDetectionStatus poseError, void* pCookie);
04698 inline XnStatus RegisterToPoseInProgress(PoseInProgress handler, void* pCookie, XnCallbackHandle& hCallback)
04699 {
04700 XnStatus nRetVal = XN_STATUS_OK;
04701
04702 PoseInProgressCookie* pPoseCookie;
04703 XN_VALIDATE_ALLOC(pPoseCookie, PoseInProgressCookie);
04704 pPoseCookie->handler = handler;
04705 pPoseCookie->pPoseCookie = pCookie;
04706
04707 nRetVal = xnRegisterToPoseDetectionInProgress(GetHandle(), PoseDetectionInProgressCallback, pPoseCookie, &pPoseCookie->hCallback);
04708 if (nRetVal != XN_STATUS_OK)
04709 {
04710 xnOSFree(pPoseCookie);
04711 return (nRetVal);
04712 }
04713
04714 hCallback = pPoseCookie;
04715
04716 return (XN_STATUS_OK);
04717 }
04718
04722 inline void UnregisterFromPoseInProgress(XnCallbackHandle hCallback)
04723 {
04724 PoseInProgressCookie* pPoseCookie = (PoseInProgressCookie*)hCallback;
04725 xnUnregisterFromPoseDetectionInProgress(GetHandle(), pPoseCookie->hCallback);
04726 xnOSFree(pPoseCookie);
04727 }
04728
04729 private:
04730 typedef struct PoseCookie
04731 {
04732 PoseDetection startHandler;
04733 PoseDetection endHandler;
04734 void* pPoseCookie;
04735 XnCallbackHandle hCallback;
04736 } PoseCookie;
04737
04738 static void XN_CALLBACK_TYPE PoseDetectionStartBundleCallback(XnNodeHandle hNode, const XnChar* strPose, XnUserID user, void* pCookie)
04739 {
04740 PoseCookie* pPoseCookie = (PoseCookie*)pCookie;
04741 PoseDetectionCapability cap(hNode);
04742 if (pPoseCookie->startHandler != NULL)
04743 {
04744 pPoseCookie->startHandler(cap, strPose, user, pPoseCookie->pPoseCookie);
04745 }
04746 }
04747
04748 static void XN_CALLBACK_TYPE PoseDetectionStartEndBundleCallback(XnNodeHandle hNode, const XnChar* strPose, XnUserID user, void* pCookie)
04749 {
04750 PoseCookie* pPoseCookie = (PoseCookie*)pCookie;
04751 PoseDetectionCapability cap(hNode);
04752 if (pPoseCookie->endHandler != NULL)
04753 {
04754 pPoseCookie->endHandler(cap, strPose, user, pPoseCookie->pPoseCookie);
04755 }
04756 }
04757 typedef struct PoseDetectionCookie
04758 {
04759 PoseDetection handler;
04760 void* pPoseCookie;
04761 XnCallbackHandle hCallback;
04762 } PoseDetectionCookie;
04763 static void XN_CALLBACK_TYPE PoseDetectionCallback(XnNodeHandle hNode, const XnChar* strPose, XnUserID user, void* pCookie)
04764 {
04765 PoseDetectionCookie* pPoseDetectionCookie = (PoseDetectionCookie*)pCookie;
04766 PoseDetectionCapability cap(hNode);
04767 if (pPoseDetectionCookie->handler != NULL)
04768 {
04769 pPoseDetectionCookie->handler(cap, strPose, user, pPoseDetectionCookie->pPoseCookie);
04770 }
04771 }
04772
04773 typedef struct PoseInProgressCookie
04774 {
04775 PoseInProgress handler;
04776 void* pPoseCookie;
04777 XnCallbackHandle hCallback;
04778 } PoseInProgressCookie;
04779
04780 static void XN_CALLBACK_TYPE PoseDetectionInProgressCallback(XnNodeHandle hNode, const XnChar* strPose, XnUserID user, XnPoseDetectionStatus poseErrors, void* pCookie)
04781 {
04782 PoseInProgressCookie* pPoseCookie = (PoseInProgressCookie*)pCookie;
04783 PoseDetectionCapability cap(hNode);
04784 if (pPoseCookie->handler != NULL)
04785 {
04786 pPoseCookie->handler(cap, strPose, user, poseErrors, pPoseCookie->pPoseCookie);
04787 }
04788 }
04789 };
04790
04795 class UserGenerator : public Generator
04796 {
04797 public:
04803 inline UserGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {}
04804 inline UserGenerator(const NodeWrapper& other) : Generator(other) {}
04805
04809 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL);
04810
04811 typedef void (XN_CALLBACK_TYPE* UserHandler)(UserGenerator& generator, XnUserID user, void* pCookie);
04812
04816 inline XnUInt16 GetNumberOfUsers() const
04817 {
04818 return xnGetNumberOfUsers(GetHandle());
04819 }
04820
04824 inline XnStatus GetUsers(XnUserID aUsers[], XnUInt16& nUsers) const
04825 {
04826 return xnGetUsers(GetHandle(), aUsers, &nUsers);
04827 }
04828
04832 inline XnStatus GetCoM(XnUserID user, XnPoint3D& com) const
04833 {
04834 return xnGetUserCoM(GetHandle(), user, &com);
04835 }
04836
04840 inline XnStatus GetUserPixels(XnUserID user, SceneMetaData& smd) const
04841 {
04842 return xnGetUserPixels(GetHandle(), user, smd.GetUnderlying());
04843 }
04844
04848 inline XnStatus RegisterUserCallbacks(UserHandler NewUserCB, UserHandler LostUserCB, void* pCookie, XnCallbackHandle& hCallback)
04849 {
04850 XnStatus nRetVal = XN_STATUS_OK;
04851
04852 UserCookie* pUserCookie;
04853 XN_VALIDATE_ALLOC(pUserCookie, UserCookie);
04854 pUserCookie->newHandler = NewUserCB;
04855 pUserCookie->lostHandler = LostUserCB;
04856 pUserCookie->pUserCookie = pCookie;
04857
04858 nRetVal = xnRegisterUserCallbacks(GetHandle(), NewUserCallback, LostUserCallback, pUserCookie, &pUserCookie->hCallback);
04859 if (nRetVal != XN_STATUS_OK)
04860 {
04861 xnOSFree(pUserCookie);
04862 return (nRetVal);
04863 }
04864
04865 hCallback = pUserCookie;
04866
04867 return (XN_STATUS_OK);
04868 }
04869
04873 inline void UnregisterUserCallbacks(XnCallbackHandle hCallback)
04874 {
04875 UserCookie* pUserCookie = (UserCookie*)hCallback;
04876 xnUnregisterUserCallbacks(GetHandle(), pUserCookie->hCallback);
04877 xnOSFree(pUserCookie);
04878 }
04879
04885 inline const SkeletonCapability GetSkeletonCap() const
04886 {
04887 return SkeletonCapability(GetHandle());
04888 }
04889
04895 inline SkeletonCapability GetSkeletonCap()
04896 {
04897 return SkeletonCapability(GetHandle());
04898 }
04899
04905 inline const PoseDetectionCapability GetPoseDetectionCap() const
04906 {
04907 return PoseDetectionCapability(GetHandle());
04908 }
04909
04915 inline PoseDetectionCapability GetPoseDetectionCap()
04916 {
04917 return PoseDetectionCapability(GetHandle());
04918 }
04919
04923 inline XnStatus RegisterToUserExit(UserHandler handler, void* pCookie, XnCallbackHandle& hCallback)
04924 {
04925 XnStatus nRetVal = XN_STATUS_OK;
04926
04927 UserSingleCookie* pUserCookie;
04928 XN_VALIDATE_ALLOC(pUserCookie, UserSingleCookie);
04929 pUserCookie->handler = handler;
04930 pUserCookie->pUserCookie = pCookie;
04931
04932 nRetVal = xnRegisterToUserExit(GetHandle(), UserSingleCallback, pUserCookie, &pUserCookie->hCallback);
04933 if (nRetVal != XN_STATUS_OK)
04934 {
04935 xnOSFree(pUserCookie);
04936 return (nRetVal);
04937 }
04938
04939 hCallback = pUserCookie;
04940
04941 return (XN_STATUS_OK);
04942 }
04943
04947 inline void UnregisterFromUserExit(XnCallbackHandle hCallback)
04948 {
04949 UserSingleCookie* pUserCookie = (UserSingleCookie*)hCallback;
04950 xnUnregisterFromUserExit(GetHandle(), pUserCookie->hCallback);
04951 xnOSFree(pUserCookie);
04952 }
04953
04957 inline XnStatus RegisterToUserReEnter(UserHandler handler, void* pCookie, XnCallbackHandle& hCallback)
04958 {
04959 XnStatus nRetVal = XN_STATUS_OK;
04960
04961 UserSingleCookie* pUserCookie;
04962 XN_VALIDATE_ALLOC(pUserCookie, UserSingleCookie);
04963 pUserCookie->handler = handler;
04964 pUserCookie->pUserCookie = pCookie;
04965
04966 nRetVal = xnRegisterToUserReEnter(GetHandle(), UserSingleCallback, pUserCookie, &pUserCookie->hCallback);
04967 if (nRetVal != XN_STATUS_OK)
04968 {
04969 xnOSFree(pUserCookie);
04970 return (nRetVal);
04971 }
04972
04973 hCallback = pUserCookie;
04974
04975 return (XN_STATUS_OK);
04976 }
04977
04981 inline void UnregisterFromUserReEnter(XnCallbackHandle hCallback)
04982 {
04983 UserSingleCookie* pUserCookie = (UserSingleCookie*)hCallback;
04984 xnUnregisterFromUserReEnter(GetHandle(), pUserCookie->hCallback);
04985 xnOSFree(pUserCookie);
04986 }
04987
04988 private:
04989 typedef struct UserCookie
04990 {
04991 UserHandler newHandler;
04992 UserHandler lostHandler;
04993 void* pUserCookie;
04994 XnCallbackHandle hCallback;
04995 } UserCookie;
04996
04997 static void XN_CALLBACK_TYPE NewUserCallback(XnNodeHandle hNode, XnUserID user, void* pCookie)
04998 {
04999 UserCookie* pUserCookie = (UserCookie*)pCookie;
05000 UserGenerator gen(hNode);
05001 if (pUserCookie->newHandler != NULL)
05002 {
05003 pUserCookie->newHandler(gen, user, pUserCookie->pUserCookie);
05004 }
05005 }
05006
05007 static void XN_CALLBACK_TYPE LostUserCallback(XnNodeHandle hNode, XnUserID user, void* pCookie)
05008 {
05009 UserCookie* pUserCookie = (UserCookie*)pCookie;
05010 UserGenerator gen(hNode);
05011 if (pUserCookie->lostHandler != NULL)
05012 {
05013 pUserCookie->lostHandler(gen, user, pUserCookie->pUserCookie);
05014 }
05015 }
05016
05017 typedef struct UserSingleCookie
05018 {
05019 UserHandler handler;
05020 void* pUserCookie;
05021 XnCallbackHandle hCallback;
05022 } UserSingleCookie;
05023
05024 static void XN_CALLBACK_TYPE UserSingleCallback(XnNodeHandle hNode, XnUserID user, void* pCookie)
05025 {
05026 UserSingleCookie* pUserCookie = (UserSingleCookie*)pCookie;
05027 UserGenerator gen(hNode);
05028 if (pUserCookie->handler != NULL)
05029 {
05030 pUserCookie->handler(gen, user, pUserCookie->pUserCookie);
05031 }
05032 }
05033 };
05034
05039 class AudioGenerator : public Generator
05040 {
05041 public:
05047 inline AudioGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {}
05048 inline AudioGenerator(const NodeWrapper& other) : Generator(other) {}
05049
05053 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL);
05054
05058 inline void GetMetaData(AudioMetaData& metaData) const
05059 {
05060 xnGetAudioMetaData(GetHandle(), metaData.GetUnderlying());
05061 }
05062
05066 inline const XnUChar* GetAudioBuffer() const
05067 {
05068 return xnGetAudioBuffer(GetHandle());
05069 }
05070
05074 inline XnUInt32 GetSupportedWaveOutputModesCount() const
05075 {
05076 return xnGetSupportedWaveOutputModesCount(GetHandle());
05077 }
05078
05082 inline XnStatus GetSupportedWaveOutputModes(XnWaveOutputMode* aSupportedModes, XnUInt32& nCount) const
05083 {
05084 return xnGetSupportedWaveOutputModes(GetHandle(), aSupportedModes, &nCount);
05085 }
05086
05090 inline XnStatus SetWaveOutputMode(const XnWaveOutputMode& OutputMode)
05091 {
05092 return xnSetWaveOutputMode(GetHandle(), &OutputMode);
05093 }
05094
05098 inline XnStatus GetWaveOutputMode(XnWaveOutputMode& OutputMode) const
05099 {
05100 return xnGetWaveOutputMode(GetHandle(), &OutputMode);
05101 }
05102
05106 inline XnStatus RegisterToWaveOutputModeChanges(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
05107 {
05108 return _RegisterToStateChange(xnRegisterToWaveOutputModeChanges, GetHandle(), handler, pCookie, hCallback);
05109 }
05110
05114 inline void UnregisterFromWaveOutputModeChanges(XnCallbackHandle hCallback)
05115 {
05116 _UnregisterFromStateChange(xnUnregisterFromWaveOutputModeChanges, GetHandle(), hCallback);
05117 }
05118 };
05119
05124 class MockAudioGenerator : public AudioGenerator
05125 {
05126 public:
05132 inline MockAudioGenerator(XnNodeHandle hNode = NULL) : AudioGenerator(hNode) {}
05133 inline MockAudioGenerator(const NodeWrapper& other) : AudioGenerator(other) {}
05134
05141 XnStatus Create(Context& context, const XnChar* strName = NULL);
05142
05149 XnStatus CreateBasedOn(AudioGenerator& other, const XnChar* strName = NULL);
05150
05154 inline XnStatus SetData(XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize, const XnUInt8* pAudioBuffer)
05155 {
05156 return xnMockAudioSetData(GetHandle(), nFrameID, nTimestamp, nDataSize, pAudioBuffer);
05157 }
05158
05166 inline XnStatus SetData(const AudioMetaData& audioMD, XnUInt32 nFrameID, XnUInt64 nTimestamp)
05167 {
05168 return SetData(nFrameID, nTimestamp, audioMD.DataSize(), audioMD.Data());
05169 }
05170
05176 inline XnStatus SetData(const AudioMetaData& audioMD)
05177 {
05178 return SetData(audioMD, audioMD.FrameID(), audioMD.Timestamp());
05179 }
05180 };
05181
05182 class MockRawGenerator : public Generator
05183 {
05184 public:
05185 MockRawGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {}
05186 MockRawGenerator(const NodeWrapper& other) : Generator(other) {}
05187
05188 inline XnStatus Create(Context& context, const XnChar* strName = NULL);
05189
05190 inline XnStatus SetData(XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize, const void* pData)
05191 {
05192 return xnMockRawSetData(GetHandle(), nFrameID, nTimestamp, nDataSize, pData);
05193 }
05194
05195 };
05196
05201 class Codec : public ProductionNode
05202 {
05203 public:
05209 inline Codec(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {}
05210 inline Codec(const NodeWrapper& other) : ProductionNode(other) {}
05211
05215 inline XnStatus Create(Context& context, XnCodecID codecID, ProductionNode& initializerNode);
05216
05220 inline XnCodecID GetCodecID() const
05221 {
05222 return xnGetCodecID(GetHandle());
05223 }
05224
05228 inline XnStatus EncodeData(const void* pSrc, XnUInt32 nSrcSize, void* pDst, XnUInt32 nDstSize, XnUInt* pnBytesWritten) const
05229 {
05230 return xnEncodeData(GetHandle(), pSrc, nSrcSize, pDst, nDstSize, pnBytesWritten);
05231 }
05232
05236 inline XnStatus DecodeData(const void* pSrc, XnUInt32 nSrcSize, void* pDst, XnUInt32 nDstSize, XnUInt* pnBytesWritten) const
05237 {
05238 return xnDecodeData(GetHandle(), pSrc, nSrcSize, pDst, nDstSize, pnBytesWritten);
05239 }
05240 };
05241
05246 class ScriptNode : public ProductionNode
05247 {
05248 public:
05254 inline ScriptNode(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {}
05255 inline ScriptNode(const NodeWrapper& other) : ProductionNode(other) {}
05256
05257 inline const XnChar* GetSupportedFormat()
05258 {
05259 return xnScriptNodeGetSupportedFormat(GetHandle());
05260 }
05261
05262 inline XnStatus LoadScriptFromFile(const XnChar* strFileName)
05263 {
05264 return xnLoadScriptFromFile(GetHandle(), strFileName);
05265 }
05266
05267 inline XnStatus LoadScriptFromString(const XnChar* strScript)
05268 {
05269 return xnLoadScriptFromString(GetHandle(), strScript);
05270 }
05271
05272 inline XnStatus Run(EnumerationErrors* pErrors);
05273 };
05274
05275
05276
05277
05282 class EnumerationErrors
05283 {
05284 public:
05286 inline EnumerationErrors() : m_pErrors(NULL), m_bAllocated(TRUE) { xnEnumerationErrorsAllocate(&m_pErrors); }
05287
05294 inline EnumerationErrors(XnEnumerationErrors* pErrors, XnBool bOwn = FALSE) : m_pErrors(pErrors), m_bAllocated(bOwn) {}
05295
05297 ~EnumerationErrors() { Free(); }
05298
05300 class Iterator
05301 {
05302 public:
05303 friend class EnumerationErrors;
05304
05310 XnBool operator==(const Iterator& other) const
05311 {
05312 return m_it == other.m_it;
05313 }
05314
05320 XnBool operator!=(const Iterator& other) const
05321 {
05322 return m_it != other.m_it;
05323 }
05324
05329 inline Iterator& operator++()
05330 {
05331 m_it = xnEnumerationErrorsGetNext(m_it);
05332 return *this;
05333 }
05334
05339 inline Iterator operator++(int)
05340 {
05341 return Iterator(xnEnumerationErrorsGetNext(m_it));
05342 }
05343
05345 inline const XnProductionNodeDescription& Description() { return *xnEnumerationErrorsGetCurrentDescription(m_it); }
05347 inline XnStatus Error() { return xnEnumerationErrorsGetCurrentError(m_it); }
05348
05349 private:
05350 inline Iterator(XnEnumerationErrorsIterator it) : m_it(it) {}
05351
05352 XnEnumerationErrorsIterator m_it;
05353 };
05354
05356 inline Iterator Begin() const { return Iterator(xnEnumerationErrorsGetFirst(m_pErrors)); }
05358 inline Iterator End() const { return Iterator(NULL); }
05359
05363 inline XnStatus ToString(XnChar* csBuffer, XnUInt32 nSize)
05364 {
05365 return xnEnumerationErrorsToString(m_pErrors, csBuffer, nSize);
05366 }
05367
05371 inline void Free()
05372 {
05373 if (m_bAllocated)
05374 {
05375 xnEnumerationErrorsFree(m_pErrors);
05376 m_pErrors = NULL;
05377 m_bAllocated = FALSE;
05378 }
05379 }
05380
05382 inline XnEnumerationErrors* GetUnderlying() { return m_pErrors; }
05383
05384 private:
05385 XnEnumerationErrors* m_pErrors;
05386 XnBool m_bAllocated;
05387 };
05388
05389
05390
05391
05392
05397 class Context
05398 {
05399 public:
05401 inline Context() : m_pContext(NULL), m_bUsingDeprecatedAPI(FALSE), m_bAllocated(FALSE), m_hShuttingDownCallback(NULL) {}
05402
05408 inline Context(XnContext* pContext) : m_pContext(NULL), m_bUsingDeprecatedAPI(FALSE), m_bAllocated(FALSE), m_hShuttingDownCallback(NULL)
05409 {
05410 SetHandle(pContext);
05411 }
05412
05419 inline Context(const Context& other) : m_pContext(NULL), m_bUsingDeprecatedAPI(FALSE), m_bAllocated(FALSE), m_hShuttingDownCallback(NULL)
05420 {
05421 SetHandle(other.m_pContext);
05422 }
05423
05425 ~Context()
05426 {
05427 SetHandle(NULL);
05428 }
05429
05430 inline Context& operator=(const Context& other)
05431 {
05432 SetHandle(other.m_pContext);
05433 return *this;
05434 }
05435
05437 inline XnContext* GetUnderlyingObject() const { return m_pContext; }
05438
05442 inline XnStatus Init()
05443 {
05444 XnContext* pContext = NULL;
05445 XnStatus nRetVal = xnInit(&pContext);
05446 XN_IS_STATUS_OK(nRetVal);
05447
05448 TakeOwnership(pContext);
05449 m_bAllocated = TRUE;
05450
05451 return (XN_STATUS_OK);
05452 }
05453
05457 inline XnStatus XN_API_DEPRECATED("Use other overload!") RunXmlScript(const XnChar* strScript, EnumerationErrors* pErrors = NULL)
05458 {
05459 m_bUsingDeprecatedAPI = TRUE;
05460 #pragma warning (push)
05461 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
05462 return xnContextRunXmlScript(m_pContext, strScript, pErrors == NULL ? NULL : pErrors->GetUnderlying());
05463 #pragma warning (pop)
05464 }
05465
05469 inline XnStatus RunXmlScript(const XnChar* strScript, ScriptNode& scriptNode, EnumerationErrors* pErrors = NULL)
05470 {
05471 XnStatus nRetVal = XN_STATUS_OK;
05472
05473 XnNodeHandle hScriptNode;
05474 nRetVal = xnContextRunXmlScriptEx(m_pContext, strScript, pErrors == NULL ? NULL : pErrors->GetUnderlying(), &hScriptNode);
05475 XN_IS_STATUS_OK(nRetVal);
05476
05477 scriptNode.TakeOwnership(hScriptNode);
05478
05479 return (XN_STATUS_OK);
05480 }
05481
05485 inline XnStatus XN_API_DEPRECATED("Use other overload!") RunXmlScriptFromFile(const XnChar* strFileName, EnumerationErrors* pErrors = NULL)
05486 {
05487 m_bUsingDeprecatedAPI = TRUE;
05488 #pragma warning (push)
05489 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
05490 return xnContextRunXmlScriptFromFile(m_pContext, strFileName, pErrors == NULL ? NULL : pErrors->GetUnderlying());
05491 #pragma warning (pop)
05492 }
05493
05497 inline XnStatus RunXmlScriptFromFile(const XnChar* strFileName, ScriptNode& scriptNode, EnumerationErrors* pErrors = NULL)
05498 {
05499 XnStatus nRetVal = XN_STATUS_OK;
05500
05501 XnNodeHandle hScriptNode;
05502 nRetVal = xnContextRunXmlScriptFromFileEx(m_pContext, strFileName, pErrors == NULL ? NULL : pErrors->GetUnderlying(), &hScriptNode);
05503 XN_IS_STATUS_OK(nRetVal);
05504
05505 scriptNode.TakeOwnership(hScriptNode);
05506
05507 return (XN_STATUS_OK);
05508 }
05509
05513 inline XnStatus XN_API_DEPRECATED("Use other overload!") InitFromXmlFile(const XnChar* strFileName, EnumerationErrors* pErrors = NULL)
05514 {
05515 XnContext* pContext = NULL;
05516 m_bUsingDeprecatedAPI = TRUE;
05517
05518 #pragma warning (push)
05519 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
05520 XnStatus nRetVal = xnInitFromXmlFile(strFileName, &pContext, pErrors == NULL ? NULL : pErrors->GetUnderlying());
05521 #pragma warning (pop)
05522 XN_IS_STATUS_OK(nRetVal);
05523
05524 TakeOwnership(pContext);
05525 m_bAllocated = TRUE;
05526
05527 return (XN_STATUS_OK);
05528 }
05529
05533 inline XnStatus InitFromXmlFile(const XnChar* strFileName, ScriptNode& scriptNode, EnumerationErrors* pErrors = NULL)
05534 {
05535 XnContext* pContext = NULL;
05536
05537 XnNodeHandle hScriptNode;
05538 XnStatus nRetVal = xnInitFromXmlFileEx(strFileName, &pContext, pErrors == NULL ? NULL : pErrors->GetUnderlying(), &hScriptNode);
05539 XN_IS_STATUS_OK(nRetVal);
05540
05541 scriptNode.TakeOwnership(hScriptNode);
05542 TakeOwnership(pContext);
05543 m_bAllocated = TRUE;
05544
05545 return (XN_STATUS_OK);
05546 }
05547
05551 inline XnStatus XN_API_DEPRECATED("Use other overload!") OpenFileRecording(const XnChar* strFileName)
05552 {
05553 m_bUsingDeprecatedAPI = TRUE;
05554 #pragma warning (push)
05555 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
05556 return xnContextOpenFileRecording(m_pContext, strFileName);
05557 #pragma warning (pop)
05558 }
05559
05563 inline XnStatus OpenFileRecording(const XnChar* strFileName, ProductionNode& playerNode)
05564 {
05565 XnStatus nRetVal = XN_STATUS_OK;
05566
05567 XnNodeHandle hPlayer;
05568 nRetVal = xnContextOpenFileRecordingEx(m_pContext, strFileName, &hPlayer);
05569 XN_IS_STATUS_OK(nRetVal);
05570
05571 playerNode.TakeOwnership(hPlayer);
05572
05573 return (XN_STATUS_OK);
05574 }
05575
05579 inline XnStatus CreateMockNode(XnProductionNodeType type, const XnChar* strName, ProductionNode& mockNode)
05580 {
05581 XnStatus nRetVal = XN_STATUS_OK;
05582
05583 XnNodeHandle hMockNode;
05584 nRetVal = xnCreateMockNode(m_pContext, type, strName, &hMockNode);
05585 XN_IS_STATUS_OK(nRetVal);
05586
05587 mockNode.TakeOwnership(hMockNode);
05588
05589 return (XN_STATUS_OK);
05590 }
05591
05595 inline XnStatus CreateMockNodeBasedOn(ProductionNode& originalNode, const XnChar* strName, ProductionNode& mockNode)
05596 {
05597 XnStatus nRetVal = XN_STATUS_OK;
05598
05599 XnNodeHandle hMockNode;
05600 nRetVal = xnCreateMockNodeBasedOn(m_pContext, originalNode, strName, &hMockNode);
05601 XN_IS_STATUS_OK(nRetVal);
05602
05603 mockNode.TakeOwnership(hMockNode);
05604
05605 return (XN_STATUS_OK);
05606 }
05607
05611 inline XnStatus CreateCodec(XnCodecID codecID, ProductionNode& initializerNode, Codec& codec)
05612 {
05613 XnStatus nRetVal = XN_STATUS_OK;
05614
05615 XnNodeHandle hCodec;
05616 nRetVal = xnCreateCodec(m_pContext, codecID, initializerNode.GetHandle(), &hCodec);
05617 XN_IS_STATUS_OK(nRetVal);
05618
05619 codec.TakeOwnership(hCodec);
05620
05621 return (XN_STATUS_OK);
05622 }
05623
05627 inline XnStatus AddRef()
05628 {
05629 return xnContextAddRef(m_pContext);
05630 }
05631
05635 inline void Release()
05636 {
05637 SetHandle(NULL);
05638 }
05639
05643 inline void XN_API_DEPRECATED("You may use Release() instead, or count on dtor") Shutdown()
05644 {
05645 if (m_pContext != NULL)
05646 {
05647 #pragma warning (push)
05648 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
05649 xnShutdown(m_pContext);
05650 #pragma warning (pop)
05651 m_pContext = NULL;
05652 }
05653 }
05654
05658 inline XnStatus AddLicense(const XnLicense& License)
05659 {
05660 return xnAddLicense(m_pContext, &License);
05661 }
05662
05666 inline XnStatus EnumerateLicenses(XnLicense*& aLicenses, XnUInt32& nCount) const
05667 {
05668 return xnEnumerateLicenses(m_pContext, &aLicenses, &nCount);
05669 }
05670
05674 inline static void FreeLicensesList(XnLicense aLicenses[])
05675 {
05676 xnFreeLicensesList(aLicenses);
05677 }
05678
05682 XnStatus EnumerateProductionTrees(XnProductionNodeType Type, const Query* pQuery, NodeInfoList& TreesList, EnumerationErrors* pErrors = NULL) const
05683 {
05684 XnStatus nRetVal = XN_STATUS_OK;
05685
05686 const XnNodeQuery* pInternalQuery = (pQuery != NULL) ? pQuery->GetUnderlyingObject() : NULL;
05687
05688 XnNodeInfoList* pList = NULL;
05689 nRetVal = xnEnumerateProductionTrees(m_pContext, Type, pInternalQuery, &pList, pErrors == NULL ? NULL : pErrors->GetUnderlying());
05690 XN_IS_STATUS_OK(nRetVal);
05691
05692 TreesList.ReplaceUnderlyingObject(pList);
05693
05694 return (XN_STATUS_OK);
05695 }
05696
05700 XnStatus CreateAnyProductionTree(XnProductionNodeType type, Query* pQuery, ProductionNode& node, EnumerationErrors* pErrors = NULL)
05701 {
05702 XnStatus nRetVal = XN_STATUS_OK;
05703
05704 XnNodeQuery* pInternalQuery = (pQuery != NULL) ? pQuery->GetUnderlyingObject() : NULL;
05705
05706 XnNodeHandle hNode;
05707 nRetVal = xnCreateAnyProductionTree(m_pContext, type, pInternalQuery, &hNode, pErrors == NULL ? NULL : pErrors->GetUnderlying());
05708 XN_IS_STATUS_OK(nRetVal);
05709
05710 node.TakeOwnership(hNode);
05711
05712 return (XN_STATUS_OK);
05713 }
05714
05718 XnStatus XN_API_DEPRECATED("Please use other overload") CreateProductionTree(NodeInfo& Tree)
05719 {
05720 XnStatus nRetVal = XN_STATUS_OK;
05721
05722 XnNodeHandle hNode;
05723 nRetVal = xnCreateProductionTree(m_pContext, Tree, &hNode);
05724 XN_IS_STATUS_OK(nRetVal);
05725
05726 Tree.m_bOwnerOfNode = TRUE;
05727
05728 return (XN_STATUS_OK);
05729 }
05730
05734 XnStatus CreateProductionTree(NodeInfo& Tree, ProductionNode& node)
05735 {
05736 XnStatus nRetVal = XN_STATUS_OK;
05737
05738 XnNodeHandle hNode;
05739 nRetVal = xnCreateProductionTree(m_pContext, Tree, &hNode);
05740 XN_IS_STATUS_OK(nRetVal);
05741
05742 node.TakeOwnership(hNode);
05743
05744 return (XN_STATUS_OK);
05745 }
05746
05750 XnStatus EnumerateExistingNodes(NodeInfoList& list) const
05751 {
05752 XnNodeInfoList* pList;
05753 XnStatus nRetVal = xnEnumerateExistingNodes(m_pContext, &pList);
05754 XN_IS_STATUS_OK(nRetVal);
05755
05756 list.ReplaceUnderlyingObject(pList);
05757
05758 return (XN_STATUS_OK);
05759 }
05760
05764 XnStatus EnumerateExistingNodes(NodeInfoList& list, XnProductionNodeType type) const
05765 {
05766 XnNodeInfoList* pList;
05767 XnStatus nRetVal = xnEnumerateExistingNodesByType(m_pContext, type, &pList);
05768 XN_IS_STATUS_OK(nRetVal);
05769
05770 list.ReplaceUnderlyingObject(pList);
05771
05772 return (XN_STATUS_OK);
05773 }
05774
05778 XnStatus FindExistingNode(XnProductionNodeType type, ProductionNode& node) const
05779 {
05780 XnStatus nRetVal = XN_STATUS_OK;
05781
05782 XnNodeHandle hNode;
05783 nRetVal = xnFindExistingRefNodeByType(m_pContext, type, &hNode);
05784 XN_IS_STATUS_OK(nRetVal);
05785
05786 node.TakeOwnership(hNode);
05787
05788 return (XN_STATUS_OK);
05789 }
05790
05794 XnStatus GetProductionNodeByName(const XnChar* strInstanceName, ProductionNode& node) const
05795 {
05796 XnStatus nRetVal = XN_STATUS_OK;
05797
05798 XnNodeHandle hNode;
05799 nRetVal = xnGetRefNodeHandleByName(m_pContext, strInstanceName, &hNode);
05800 XN_IS_STATUS_OK(nRetVal);
05801
05802 node.TakeOwnership(hNode);
05803
05804 return (XN_STATUS_OK);
05805 }
05806
05810 XnStatus GetProductionNodeInfoByName(const XnChar* strInstanceName, NodeInfo& nodeInfo) const
05811 {
05812 XnStatus nRetVal = XN_STATUS_OK;
05813
05814 XnNodeHandle hNode;
05815 nRetVal = xnGetRefNodeHandleByName(m_pContext, strInstanceName, &hNode);
05816 XN_IS_STATUS_OK(nRetVal);
05817
05818 xnProductionNodeRelease(hNode);
05819
05820 nodeInfo = NodeInfo(xnGetNodeInfo(hNode));
05821
05822 return (XN_STATUS_OK);
05823 }
05824
05828 inline XnStatus StartGeneratingAll()
05829 {
05830 return xnStartGeneratingAll(m_pContext);
05831 }
05832
05836 inline XnStatus StopGeneratingAll()
05837 {
05838 return xnStopGeneratingAll(m_pContext);
05839 }
05840
05844 inline XnStatus SetGlobalMirror(XnBool bMirror)
05845 {
05846 return xnSetGlobalMirror(m_pContext, bMirror);
05847 }
05848
05852 inline XnBool GetGlobalMirror()
05853 {
05854 return xnGetGlobalMirror(m_pContext);
05855 }
05856
05860 inline XnStatus GetGlobalErrorState()
05861 {
05862 return xnGetGlobalErrorState(m_pContext);
05863 }
05864
05868 inline XnStatus RegisterToErrorStateChange(XnErrorStateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
05869 {
05870 return xnRegisterToGlobalErrorStateChange(m_pContext, handler, pCookie, &hCallback);
05871 }
05872
05877 inline void UnregisterFromErrorStateChange(XnCallbackHandle hCallback)
05878 {
05879 xnUnregisterFromGlobalErrorStateChange(m_pContext, hCallback);
05880 }
05881
05885 inline XnStatus WaitAndUpdateAll()
05886 {
05887 return xnWaitAndUpdateAll(m_pContext);
05888 }
05889
05893 inline XnStatus WaitAnyUpdateAll()
05894 {
05895 return xnWaitAnyUpdateAll(m_pContext);
05896 }
05897
05901 inline XnStatus WaitOneUpdateAll(ProductionNode& node)
05902 {
05903 return xnWaitOneUpdateAll(m_pContext, node.GetHandle());
05904 }
05905
05909 inline XnStatus WaitNoneUpdateAll()
05910 {
05911 return xnWaitNoneUpdateAll(m_pContext);
05912 }
05913
05917 inline XnStatus AutoEnumerateOverSingleInput(NodeInfoList& List, XnProductionNodeDescription& description, const XnChar* strCreationInfo, XnProductionNodeType InputType, EnumerationErrors* pErrors, Query* pQuery = NULL) const
05918 {
05919 return xnAutoEnumerateOverSingleInput(m_pContext, List.GetUnderlyingObject(), &description, strCreationInfo, InputType, pErrors == NULL ? NULL : pErrors->GetUnderlying(), pQuery == NULL ? NULL : pQuery->GetUnderlyingObject());
05920 }
05921
05923 inline void SetHandle(XnContext* pContext)
05924 {
05925 if (m_pContext == pContext)
05926 {
05927 return;
05928 }
05929
05930 if (m_pContext != NULL)
05931 {
05932 if (m_bUsingDeprecatedAPI && m_bAllocated)
05933 {
05934
05935
05936 xnForceShutdown(m_pContext);
05937 }
05938 else
05939 {
05940 xnContextUnregisterFromShutdown(m_pContext, m_hShuttingDownCallback);
05941 xnContextRelease(m_pContext);
05942 }
05943 }
05944
05945 if (pContext != NULL)
05946 {
05947 XnStatus nRetVal = xnContextAddRef(pContext);
05948 XN_ASSERT(nRetVal == XN_STATUS_OK);
05949
05950 nRetVal = xnContextRegisterForShutdown(pContext, ContextShuttingDownCallback, this, &m_hShuttingDownCallback);
05951 XN_ASSERT(nRetVal == XN_STATUS_OK);
05952 }
05953
05954 m_pContext = pContext;
05955 }
05956
05957 inline void TakeOwnership(XnContext* pContext)
05958 {
05959 SetHandle(pContext);
05960
05961 if (pContext != NULL)
05962 {
05963 xnContextRelease(pContext);
05964 }
05965 }
05966
05967 private:
05968 static void XN_CALLBACK_TYPE ContextShuttingDownCallback(XnContext* , void* pCookie)
05969 {
05970 Context* pThis = (Context*)pCookie;
05971 pThis->m_pContext = NULL;
05972 }
05973
05974 XnContext* m_pContext;
05975 XnBool m_bUsingDeprecatedAPI;
05976 XnBool m_bAllocated;
05977 XnCallbackHandle m_hShuttingDownCallback;
05978 };
05979
05984 class Resolution
05985 {
05986 public:
05992 inline Resolution(XnResolution res) : m_Res(res)
05993 {
05994 m_nXRes = xnResolutionGetXRes(res);
05995 m_nYRes = xnResolutionGetYRes(res);
05996 m_strName = xnResolutionGetName(res);
05997 }
05998
06005 inline Resolution(XnUInt32 xRes, XnUInt32 yRes) : m_nXRes(xRes), m_nYRes(yRes)
06006 {
06007 m_Res = xnResolutionGetFromXYRes(xRes, yRes);
06008 m_strName = xnResolutionGetName(m_Res);
06009 }
06010
06016 inline Resolution(const XnChar* strName)
06017 {
06018 m_Res = xnResolutionGetFromName(strName);
06019 m_nXRes = xnResolutionGetXRes(m_Res);
06020 m_nYRes = xnResolutionGetYRes(m_Res);
06021 m_strName = xnResolutionGetName(m_Res);
06022 }
06023
06025 inline XnResolution GetResolution() const { return m_Res; }
06027 inline XnUInt32 GetXResolution() const { return m_nXRes; }
06029 inline XnUInt32 GetYResolution() const { return m_nYRes; }
06031 inline const XnChar* GetName() const { return m_strName; }
06032
06033 private:
06034 XnResolution m_Res;
06035 XnUInt32 m_nXRes;
06036 XnUInt32 m_nYRes;
06037 const XnChar* m_strName;
06038 };
06039
06040
06041
06042
06043 inline XnStatus NodeInfoList::FilterList(Context& context, Query& query)
06044 {
06045 return xnNodeQueryFilterList(context.GetUnderlyingObject(), query.GetUnderlyingObject(), m_pList);
06046 }
06047
06048 inline void ProductionNode::GetContext(Context& context) const
06049 {
06050 context.TakeOwnership(xnGetRefContextFromNodeHandle(GetHandle()));
06051 }
06052
06053 inline NodeInfoList& NodeInfo::GetNeededNodes() const
06054 {
06055 if (m_pNeededNodes == NULL)
06056 {
06057 XnNodeInfoList* pList = xnNodeInfoGetNeededNodes(m_pInfo);
06058 m_pNeededNodes = XN_NEW(NodeInfoList, pList);
06059 }
06060
06061 return *m_pNeededNodes;
06062 }
06063
06064 inline void NodeInfo::SetUnderlyingObject(XnNodeInfo* pInfo)
06065 {
06066 if (m_pNeededNodes != NULL)
06067 {
06068 XN_DELETE(m_pNeededNodes);
06069 }
06070
06071 m_bOwnerOfNode = FALSE;
06072 m_pInfo = pInfo;
06073 m_pNeededNodes = NULL;
06074 }
06075
06076 inline XnBool FrameSyncCapability::CanFrameSyncWith(Generator& other) const
06077 {
06078 return xnCanFrameSyncWith(GetHandle(), other.GetHandle());
06079 }
06080
06081 inline XnStatus FrameSyncCapability::FrameSyncWith(Generator& other)
06082 {
06083 return xnFrameSyncWith(GetHandle(), other.GetHandle());
06084 }
06085
06086 inline XnStatus FrameSyncCapability::StopFrameSyncWith(Generator& other)
06087 {
06088 return xnStopFrameSyncWith(GetHandle(), other.GetHandle());
06089 }
06090
06091 inline XnBool FrameSyncCapability::IsFrameSyncedWith(Generator& other) const
06092 {
06093 return xnIsFrameSyncedWith(GetHandle(), other.GetHandle());
06094 }
06095
06096 inline XnStatus NodeInfo::GetInstance(ProductionNode& node) const
06097 {
06098 if (m_pInfo == NULL)
06099 {
06100 return XN_STATUS_INVALID_OPERATION;
06101 }
06102
06103 XnNodeHandle hNode = xnNodeInfoGetRefHandle(m_pInfo);
06104 node.TakeOwnership(hNode);
06105
06106 if (m_bOwnerOfNode)
06107 {
06108 xnProductionNodeRelease(hNode);
06109 }
06110
06111 return (XN_STATUS_OK);
06112 }
06113
06114
06115
06116
06117
06118 inline XnStatus Device::Create(Context& context, Query* pQuery, EnumerationErrors* pErrors)
06119 {
06120 XnNodeHandle hNode;
06121 XnStatus nRetVal = xnCreateDevice(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06122 XN_IS_STATUS_OK(nRetVal);
06123 TakeOwnership(hNode);
06124 return (XN_STATUS_OK);
06125 }
06126
06127 inline XnStatus Recorder::Create(Context& context, const XnChar* strFormatName )
06128 {
06129 XnNodeHandle hNode;
06130 XnStatus nRetVal = xnCreateRecorder(context.GetUnderlyingObject(), strFormatName, &hNode);
06131 XN_IS_STATUS_OK(nRetVal);
06132 TakeOwnership(hNode);
06133 return (XN_STATUS_OK);
06134 }
06135
06136 inline XnStatus Player::Create(Context& context, const XnChar* strFormatName)
06137 {
06138 XnNodeHandle hNode;
06139 XnStatus nRetVal = xnCreatePlayer(context.GetUnderlyingObject(), strFormatName, &hNode);
06140 XN_IS_STATUS_OK(nRetVal);
06141 TakeOwnership(hNode);
06142 return (XN_STATUS_OK);
06143 }
06144
06145 inline XnStatus DepthGenerator::Create(Context& context, Query* pQuery, EnumerationErrors* pErrors)
06146 {
06147 XnNodeHandle hNode;
06148 XnStatus nRetVal = xnCreateDepthGenerator(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06149 XN_IS_STATUS_OK(nRetVal);
06150 TakeOwnership(hNode);
06151 return (XN_STATUS_OK);
06152 }
06153
06154 inline XnStatus MockDepthGenerator::Create(Context& context, const XnChar* strName )
06155 {
06156 XnNodeHandle hNode;
06157 XnStatus nRetVal = xnCreateMockNode(context.GetUnderlyingObject(), XN_NODE_TYPE_DEPTH, strName, &hNode);
06158 XN_IS_STATUS_OK(nRetVal);
06159 TakeOwnership(hNode);
06160 return (XN_STATUS_OK);
06161 }
06162
06163 inline XnStatus MockDepthGenerator::CreateBasedOn(DepthGenerator& other, const XnChar* strName )
06164 {
06165 Context context;
06166 other.GetContext(context);
06167 XnNodeHandle hNode;
06168 XnStatus nRetVal = xnCreateMockNodeBasedOn(context.GetUnderlyingObject(), other.GetHandle(), strName, &hNode);
06169 XN_IS_STATUS_OK(nRetVal);
06170 TakeOwnership(hNode);
06171 return (XN_STATUS_OK);
06172 }
06173
06174 inline XnStatus ImageGenerator::Create(Context& context, Query* pQuery, EnumerationErrors* pErrors)
06175 {
06176 XnNodeHandle hNode;
06177 XnStatus nRetVal = xnCreateImageGenerator(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06178 XN_IS_STATUS_OK(nRetVal);
06179 TakeOwnership(hNode);
06180 return (XN_STATUS_OK);
06181 }
06182
06183 inline XnStatus MockImageGenerator::Create(Context& context, const XnChar* strName )
06184 {
06185 XnNodeHandle hNode;
06186 XnStatus nRetVal = xnCreateMockNode(context.GetUnderlyingObject(), XN_NODE_TYPE_IMAGE, strName, &hNode);
06187 XN_IS_STATUS_OK(nRetVal);
06188 TakeOwnership(hNode);
06189 return (XN_STATUS_OK);
06190 }
06191
06192 inline XnStatus MockImageGenerator::CreateBasedOn(ImageGenerator& other, const XnChar* strName )
06193 {
06194 Context context;
06195 other.GetContext(context);
06196 XnNodeHandle hNode;
06197 XnStatus nRetVal = xnCreateMockNodeBasedOn(context.GetUnderlyingObject(), other.GetHandle(), strName, &hNode);
06198 XN_IS_STATUS_OK(nRetVal);
06199 TakeOwnership(hNode);
06200 return (XN_STATUS_OK);
06201 }
06202
06203 inline XnStatus IRGenerator::Create(Context& context, Query* pQuery, EnumerationErrors* pErrors)
06204 {
06205 XnNodeHandle hNode;
06206 XnStatus nRetVal = xnCreateIRGenerator(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06207 XN_IS_STATUS_OK(nRetVal);
06208 TakeOwnership(hNode);
06209 return (XN_STATUS_OK);
06210 }
06211
06212 inline XnStatus MockIRGenerator::Create(Context& context, const XnChar* strName )
06213 {
06214 XnNodeHandle hNode;
06215 XnStatus nRetVal = xnCreateMockNode(context.GetUnderlyingObject(), XN_NODE_TYPE_IR, strName, &hNode);
06216 XN_IS_STATUS_OK(nRetVal);
06217 TakeOwnership(hNode);
06218 return (XN_STATUS_OK);
06219 }
06220
06221 inline XnStatus MockIRGenerator::CreateBasedOn(IRGenerator& other, const XnChar* strName )
06222 {
06223 Context context;
06224 other.GetContext(context);
06225 XnNodeHandle hNode;
06226 XnStatus nRetVal = xnCreateMockNodeBasedOn(context.GetUnderlyingObject(), other.GetHandle(), strName, &hNode);
06227 XN_IS_STATUS_OK(nRetVal);
06228 TakeOwnership(hNode);
06229 return (XN_STATUS_OK);
06230 }
06231
06232 inline XnStatus GestureGenerator::Create(Context& context, Query* pQuery, EnumerationErrors* pErrors)
06233 {
06234 XnNodeHandle hNode;
06235 XnStatus nRetVal = xnCreateGestureGenerator(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06236 XN_IS_STATUS_OK(nRetVal);
06237 TakeOwnership(hNode);
06238 return (XN_STATUS_OK);
06239 }
06240
06241 inline XnStatus SceneAnalyzer::Create(Context& context, Query* pQuery, EnumerationErrors* pErrors)
06242 {
06243
06244 XnNodeHandle hNode;
06245 XnStatus nRetVal = xnCreateSceneAnalyzer(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06246 XN_IS_STATUS_OK(nRetVal);
06247 TakeOwnership(hNode);
06248 return (XN_STATUS_OK);
06249 }
06250
06251 inline XnStatus HandsGenerator::Create(Context& context, Query* pQuery, EnumerationErrors* pErrors)
06252 {
06253 XnNodeHandle hNode;
06254 XnStatus nRetVal = xnCreateHandsGenerator(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06255 XN_IS_STATUS_OK(nRetVal);
06256 TakeOwnership(hNode);
06257 return (XN_STATUS_OK);
06258 }
06259
06260 inline XnStatus UserGenerator::Create(Context& context, Query* pQuery, EnumerationErrors* pErrors)
06261 {
06262 XnNodeHandle hNode;
06263 XnStatus nRetVal = xnCreateUserGenerator(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06264 XN_IS_STATUS_OK(nRetVal);
06265 TakeOwnership(hNode);
06266 return (XN_STATUS_OK);
06267 }
06268
06269 inline XnStatus AudioGenerator::Create(Context& context, Query* pQuery, EnumerationErrors* pErrors)
06270 {
06271 XnNodeHandle hNode;
06272 XnStatus nRetVal = xnCreateAudioGenerator(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06273 XN_IS_STATUS_OK(nRetVal);
06274 TakeOwnership(hNode);
06275 return (XN_STATUS_OK);
06276 }
06277
06278 inline XnStatus MockAudioGenerator::Create(Context& context, const XnChar* strName )
06279 {
06280 XnNodeHandle hNode;
06281 XnStatus nRetVal = xnCreateMockNode(context.GetUnderlyingObject(), XN_NODE_TYPE_AUDIO, strName, &hNode);
06282 XN_IS_STATUS_OK(nRetVal);
06283 TakeOwnership(hNode);
06284 return (XN_STATUS_OK);
06285 }
06286
06287 inline XnStatus MockAudioGenerator::CreateBasedOn(AudioGenerator& other, const XnChar* strName )
06288 {
06289 Context context;
06290 other.GetContext(context);
06291 XnNodeHandle hNode;
06292 XnStatus nRetVal = xnCreateMockNodeBasedOn(context.GetUnderlyingObject(), other.GetHandle(), strName, &hNode);
06293 XN_IS_STATUS_OK(nRetVal);
06294 TakeOwnership(hNode);
06295 return (XN_STATUS_OK);
06296 }
06297
06298 inline XnStatus MockRawGenerator::Create(Context& context, const XnChar* strName )
06299 {
06300 XnNodeHandle hNode;
06301 XnStatus nRetVal = xnCreateMockNode(context.GetUnderlyingObject(), XN_NODE_TYPE_GENERATOR, strName, &hNode);
06302 XN_IS_STATUS_OK(nRetVal);
06303 TakeOwnership(hNode);
06304 return (XN_STATUS_OK);
06305 }
06306
06307 inline XnStatus Codec::Create(Context& context, XnCodecID codecID, ProductionNode& initializerNode)
06308 {
06309 XnNodeHandle hNode;
06310 XnStatus nRetVal = xnCreateCodec(context.GetUnderlyingObject(), codecID, initializerNode.GetHandle(), &hNode);
06311 XN_IS_STATUS_OK(nRetVal);
06312 TakeOwnership(hNode);
06313 return (XN_STATUS_OK);
06314 }
06315
06316 inline XnStatus ScriptNode::Run(EnumerationErrors* pErrors)
06317 {
06318 return xnScriptNodeRun(GetHandle(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06319 }
06320
06321
06322
06323
06324
06328 inline void GetVersion(XnVersion& Version)
06329 {
06330 xnGetVersion(&Version);
06331 }
06332
06333
06334
06335
06336
06337 class StateChangedCallbackTranslator
06338 {
06339 public:
06340 StateChangedCallbackTranslator(StateChangedHandler handler, void* pCookie) : m_UserHandler(handler), m_pUserCookie(pCookie), m_hCallback(NULL) {}
06341
06342 XnStatus Register(_XnRegisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode)
06343 {
06344 return xnFunc(hNode, StateChangedCallback, this, &m_hCallback);
06345 }
06346
06347 void Unregister(_XnUnregisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode)
06348 {
06349 xnFunc(hNode, m_hCallback);
06350 }
06351
06352 static XnStatus RegisterToUnderlying(_XnRegisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode, StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
06353 {
06354 XnStatus nRetVal = XN_STATUS_OK;
06355
06356 StateChangedCallbackTranslator* pTrans;
06357 XN_VALIDATE_NEW(pTrans, StateChangedCallbackTranslator, handler, pCookie);
06358
06359 nRetVal = pTrans->Register(xnFunc, hNode);
06360 if (nRetVal != XN_STATUS_OK)
06361 {
06362 XN_DELETE(pTrans);
06363 return (nRetVal);
06364 }
06365
06366 hCallback = pTrans;
06367
06368 return (XN_STATUS_OK);
06369 }
06370
06371 static XnStatus UnregisterFromUnderlying(_XnUnregisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode, XnCallbackHandle hCallback)
06372 {
06373 StateChangedCallbackTranslator* pTrans = (StateChangedCallbackTranslator*)hCallback;
06374 pTrans->Unregister(xnFunc, hNode);
06375 XN_DELETE(pTrans);
06376 return XN_STATUS_OK;
06377 }
06378
06379 private:
06380 friend class GeneralIntCapability;
06381
06382 typedef struct StateChangeCookie
06383 {
06384 StateChangedHandler userHandler;
06385 void* pUserCookie;
06386 XnCallbackHandle hCallback;
06387 } StateChangeCookie;
06388
06389 static void XN_CALLBACK_TYPE StateChangedCallback(XnNodeHandle hNode, void* pCookie)
06390 {
06391 StateChangedCallbackTranslator* pTrans = (StateChangedCallbackTranslator*)pCookie;
06392 ProductionNode node(hNode);
06393 pTrans->m_UserHandler(node, pTrans->m_pUserCookie);
06394 }
06395
06396 StateChangedHandler m_UserHandler;
06397 void* m_pUserCookie;
06398 XnCallbackHandle m_hCallback;
06399 };
06400
06401 static XnStatus _RegisterToStateChange(_XnRegisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode, StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
06402 {
06403 return StateChangedCallbackTranslator::RegisterToUnderlying(xnFunc, hNode, handler, pCookie, hCallback);
06404 }
06405
06406 static void _UnregisterFromStateChange(_XnUnregisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode, XnCallbackHandle hCallback)
06407 {
06408 StateChangedCallbackTranslator::UnregisterFromUnderlying(xnFunc, hNode, hCallback);
06409 }
06410
06411 inline XnStatus GeneralIntCapability::RegisterToValueChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
06412 {
06413 XnStatus nRetVal = XN_STATUS_OK;
06414
06415 StateChangedCallbackTranslator* pTrans;
06416 XN_VALIDATE_NEW(pTrans, StateChangedCallbackTranslator, handler, pCookie);
06417
06418 nRetVal = xnRegisterToGeneralIntValueChange(GetHandle(), m_strCap, pTrans->StateChangedCallback, pTrans, &pTrans->m_hCallback);
06419 if (nRetVal != XN_STATUS_OK)
06420 {
06421 XN_DELETE(pTrans);
06422 return (nRetVal);
06423 }
06424
06425 hCallback = pTrans;
06426
06427 return (XN_STATUS_OK);
06428 }
06429
06430 inline void GeneralIntCapability::UnregisterFromValueChange(XnCallbackHandle hCallback)
06431 {
06432 StateChangedCallbackTranslator* pTrans = (StateChangedCallbackTranslator*)hCallback;
06433 xnUnregisterFromGeneralIntValueChange(GetHandle(), m_strCap, pTrans->m_hCallback);
06434 XN_DELETE(pTrans);
06435 }
06436
06438 };
06439
06440 #endif // __XN_CPP_WRAPPER_H__