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_ppData(ppData), m_nAllocatedSize(0), m_pAllocatedData(NULL)
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
01155 NodeInfo(const NodeInfo& other) : m_pNeededNodes(NULL), m_bOwnerOfNode(FALSE)
01156 {
01157 SetUnderlyingObject(other.m_pInfo);
01158 }
01159
01161 ~NodeInfo()
01162 {
01163 SetUnderlyingObject(NULL);
01164 }
01165
01171 inline NodeInfo& operator=(const NodeInfo& other)
01172 {
01173 SetUnderlyingObject(other.m_pInfo);
01174 return *this;
01175 }
01176
01178 inline operator XnNodeInfo*()
01179 {
01180 return m_pInfo;
01181 }
01182
01186 inline XnStatus SetInstanceName(const XnChar* strName)
01187 {
01188 return xnNodeInfoSetInstanceName(m_pInfo, strName);
01189 }
01190
01194 inline const XnProductionNodeDescription& GetDescription() const
01195 {
01196 return *xnNodeInfoGetDescription(m_pInfo);
01197 }
01198
01202 inline const XnChar* GetInstanceName() const
01203 {
01204 return xnNodeInfoGetInstanceName(m_pInfo);
01205 }
01206 inline const XnChar* GetCreationInfo() const
01210 {
01211 return xnNodeInfoGetCreationInfo(m_pInfo);
01212 }
01213
01217 inline NodeInfoList& GetNeededNodes() const;
01218
01226 inline XnStatus GetInstance(ProductionNode& node) const;
01227
01231 inline const void* GetAdditionalData() const
01232 {
01233 return xnNodeInfoGetAdditionalData(m_pInfo);
01234 }
01235
01236 private:
01237 inline void SetUnderlyingObject(XnNodeInfo* pInfo);
01238
01239 XnNodeInfo* m_pInfo;
01240 mutable NodeInfoList* m_pNeededNodes;
01241 XnBool m_bOwnerOfNode;
01242 friend class Context;
01243 };
01244
01245
01246
01247
01248
01254 class Query
01255 {
01256 public:
01258 inline Query() : m_bAllocated(TRUE)
01259 {
01260 xnNodeQueryAllocate(&m_pQuery);
01261 }
01262
01263 inline Query(XnNodeQuery* pNodeQuery) : m_bAllocated(FALSE), m_pQuery(pNodeQuery)
01264 {
01265 }
01266
01268 ~Query()
01269 {
01270 if (m_bAllocated)
01271 {
01272 xnNodeQueryFree(m_pQuery);
01273 }
01274 }
01275
01277 inline const XnNodeQuery* GetUnderlyingObject() const { return m_pQuery; }
01278 inline XnNodeQuery* GetUnderlyingObject() { return m_pQuery; }
01279
01283 inline XnStatus SetVendor(const XnChar* strVendor)
01284 {
01285 return xnNodeQuerySetVendor(m_pQuery, strVendor);
01286 }
01287
01291 inline XnStatus SetName(const XnChar* strName)
01292 {
01293 return xnNodeQuerySetName(m_pQuery, strName);
01294 }
01295
01299 inline XnStatus SetMinVersion(const XnVersion& minVersion)
01300 {
01301 return xnNodeQuerySetMinVersion(m_pQuery, &minVersion);
01302 }
01303
01307 inline XnStatus SetMaxVersion(const XnVersion& maxVersion)
01308 {
01309 return xnNodeQuerySetMaxVersion(m_pQuery, &maxVersion);
01310 }
01311
01315 inline XnStatus AddSupportedCapability(const XnChar* strNeededCapability)
01316 {
01317 return xnNodeQueryAddSupportedCapability(m_pQuery, strNeededCapability);
01318 }
01319
01323 inline XnStatus AddSupportedMapOutputMode(const XnMapOutputMode& MapOutputMode)
01324 {
01325 return xnNodeQueryAddSupportedMapOutputMode(m_pQuery, &MapOutputMode);
01326 }
01327
01331 inline XnStatus SetSupportedMinUserPositions(const XnUInt32 nCount)
01332 {
01333 return xnNodeQuerySetSupportedMinUserPositions(m_pQuery, nCount);
01334 }
01335
01339 inline XnStatus SetExistingNodeOnly(XnBool bExistingNode)
01340 {
01341 return xnNodeQuerySetExistingNodeOnly(m_pQuery, bExistingNode);
01342 }
01343
01347 inline XnStatus AddNeededNode(const XnChar* strInstanceName)
01348 {
01349 return xnNodeQueryAddNeededNode(m_pQuery, strInstanceName);
01350 }
01351
01355 inline XnStatus SetCreationInfo(const XnChar* strCreationInfo)
01356 {
01357 return xnNodeQuerySetCreationInfo(m_pQuery, strCreationInfo);
01358 }
01359
01360 private:
01361 XnNodeQuery* m_pQuery;
01362 XnBool m_bAllocated;
01363 };
01364
01365
01366
01367
01368
01373 class NodeInfoList
01374 {
01375 public:
01377 class Iterator
01378 {
01379 public:
01380 friend class NodeInfoList;
01381
01387 XnBool operator==(const Iterator& other) const
01388 {
01389 return m_it.pCurrent == other.m_it.pCurrent;
01390 }
01391
01397 XnBool operator!=(const Iterator& other) const
01398 {
01399 return m_it.pCurrent != other.m_it.pCurrent;
01400 }
01401
01406 inline Iterator& operator++()
01407 {
01408 UpdateInternalObject(xnNodeInfoListGetNext(m_it));
01409 return *this;
01410 }
01411
01416 inline Iterator operator++(int)
01417 {
01418 XnNodeInfoListIterator curr = m_it;
01419 UpdateInternalObject(xnNodeInfoListGetNext(m_it));
01420 return Iterator(curr);
01421 }
01422
01426 inline Iterator& operator--()
01427 {
01428 UpdateInternalObject(xnNodeInfoListGetPrevious(m_it));
01429 return *this;
01430 }
01431
01435 inline Iterator operator--(int)
01436 {
01437 XnNodeInfoListIterator curr = m_it;
01438 UpdateInternalObject(xnNodeInfoListGetPrevious(m_it));
01439 return Iterator(curr);
01440 }
01441
01443 inline NodeInfo operator*()
01444 {
01445 return m_Info;
01446 }
01447
01448 private:
01449 inline Iterator(XnNodeInfoListIterator it) : m_Info(NULL)
01450 {
01451 UpdateInternalObject(it);
01452 }
01453
01454 inline void UpdateInternalObject(XnNodeInfoListIterator it)
01455 {
01456 m_it = it;
01457 if (xnNodeInfoListIteratorIsValid(it))
01458 {
01459 XnNodeInfo* pInfo = xnNodeInfoListGetCurrent(it);
01460 m_Info = NodeInfo(pInfo);
01461 }
01462 else
01463 {
01464 m_Info = NodeInfo(NULL);
01465 }
01466 }
01467
01468 NodeInfo m_Info;
01469 XnNodeInfoListIterator m_it;
01470 };
01471
01475 inline NodeInfoList()
01476 {
01477 xnNodeInfoListAllocate(&m_pList);
01478 m_bAllocated = TRUE;
01479 }
01480
01487 inline NodeInfoList(XnNodeInfoList* pList) : m_pList(pList), m_bAllocated(FALSE) {}
01488
01490 inline ~NodeInfoList()
01491 {
01492 FreeImpl();
01493 }
01494
01496 inline XnNodeInfoList* GetUnderlyingObject() const { return m_pList; }
01497
01504 inline void ReplaceUnderlyingObject(XnNodeInfoList* pList)
01505 {
01506 FreeImpl();
01507 m_pList = pList;
01508 m_bAllocated = TRUE;
01509 }
01510
01514 inline XnStatus Add(XnProductionNodeDescription& description, const XnChar* strCreationInfo, NodeInfoList* pNeededNodes)
01515 {
01516 XnNodeInfoList* pList = (pNeededNodes == NULL) ? NULL : pNeededNodes->GetUnderlyingObject();
01517 return xnNodeInfoListAdd(m_pList, &description, strCreationInfo, pList);
01518 }
01519
01523 inline XnStatus AddEx(XnProductionNodeDescription& description, const XnChar* strCreationInfo, NodeInfoList* pNeededNodes, const void* pAdditionalData, XnFreeHandler pFreeHandler)
01524 {
01525 XnNodeInfoList* pList = (pNeededNodes == NULL) ? NULL : pNeededNodes->GetUnderlyingObject();
01526 return xnNodeInfoListAddEx(m_pList, &description, strCreationInfo, pList, pAdditionalData, pFreeHandler);
01527 }
01528
01532 inline XnStatus AddNode(NodeInfo& info)
01533 {
01534 return xnNodeInfoListAddNode(m_pList, info);
01535 }
01536
01540 inline XnStatus AddNodeFromAnotherList(Iterator& it)
01541 {
01542 return xnNodeInfoListAddNodeFromList(m_pList, it.m_it);
01543 }
01544
01546 inline Iterator Begin() const
01547 {
01548 return Iterator(xnNodeInfoListGetFirst(m_pList));
01549 }
01550
01552 inline Iterator End() const
01553 {
01554 XnNodeInfoListIterator it = { NULL };
01555 return Iterator(it);
01556 }
01557
01559 inline Iterator RBegin() const
01560 {
01561 return Iterator(xnNodeInfoListGetLast(m_pList));
01562 }
01563
01565 inline Iterator REnd() const
01566 {
01567 XnNodeInfoListIterator it = { NULL };
01568 return Iterator(it);
01569 }
01570
01574 inline XnStatus Remove(Iterator& it)
01575 {
01576 return xnNodeInfoListRemove(m_pList, it.m_it);
01577 }
01578
01582 inline XnStatus Clear()
01583 {
01584 return xnNodeInfoListClear(m_pList);
01585 }
01586
01590 inline XnStatus Append(NodeInfoList& other)
01591 {
01592 return xnNodeInfoListAppend(m_pList, other.GetUnderlyingObject());
01593 }
01594
01598 inline XnBool IsEmpty()
01599 {
01600 return xnNodeInfoListIsEmpty(m_pList);
01601 }
01602
01606 inline XnStatus FilterList(Context& context, Query& query);
01607
01608 private:
01609 inline void FreeImpl()
01610 {
01611 if (m_bAllocated)
01612 {
01613 xnNodeInfoListFree(m_pList);
01614 m_bAllocated = FALSE;
01615 m_pList = NULL;
01616 }
01617 }
01618
01619 XnNodeInfoList* m_pList;
01620 XnBool m_bAllocated;
01621 };
01622
01623
01624
01625
01626
01631 class Capability : public NodeWrapper
01632 {
01633 public:
01639 Capability(XnNodeHandle hNode) : NodeWrapper(hNode) {}
01640 Capability(const NodeWrapper& node) : NodeWrapper(node) {}
01641 };
01642
01647 class ErrorStateCapability : public Capability
01648 {
01649 public:
01655 ErrorStateCapability(XnNodeHandle hNode) : Capability(hNode) {}
01656 ErrorStateCapability(const NodeWrapper& node) : Capability(node) {}
01657
01661 inline XnStatus GetErrorState() const
01662 {
01663 return xnGetNodeErrorState(GetHandle());
01664 }
01665
01669 inline XnStatus RegisterToErrorStateChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
01670 {
01671 return _RegisterToStateChange(xnRegisterToNodeErrorStateChange, GetHandle(), handler, pCookie, hCallback);
01672 }
01673
01677 inline void UnregisterFromErrorStateChange(XnCallbackHandle hCallback)
01678 {
01679 _UnregisterFromStateChange(xnUnregisterFromNodeErrorStateChange, GetHandle(), hCallback);
01680 }
01681 };
01682
01687 class GeneralIntCapability : public Capability
01688 {
01689 public:
01696 GeneralIntCapability(XnNodeHandle hNode, const XnChar* strCap) : Capability(hNode), m_strCap(strCap) {}
01697 GeneralIntCapability(const NodeWrapper& node) : Capability(node) {}
01698
01702 inline void GetRange(XnInt32& nMin, XnInt32& nMax, XnInt32& nStep, XnInt32& nDefault, XnBool& bIsAutoSupported) const
01703 {
01704 xnGetGeneralIntRange(GetHandle(), m_strCap, &nMin, &nMax, &nStep, &nDefault, &bIsAutoSupported);
01705 }
01706
01710 inline XnInt32 Get()
01711 {
01712 XnInt32 nValue;
01713 xnGetGeneralIntValue(GetHandle(), m_strCap, &nValue);
01714 return nValue;
01715 }
01716
01720 inline XnStatus Set(XnInt32 nValue)
01721 {
01722 return xnSetGeneralIntValue(GetHandle(), m_strCap, nValue);
01723 }
01724
01728 XnStatus RegisterToValueChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback);
01729
01733 void UnregisterFromValueChange(XnCallbackHandle hCallback);
01734
01735 private:
01736 const XnChar* m_strCap;
01737 };
01738
01743 class ProductionNode : public NodeWrapper
01744 {
01745 public:
01751 inline ProductionNode(XnNodeHandle hNode = NULL) : NodeWrapper(hNode) {}
01752 inline ProductionNode(const NodeWrapper& other) : NodeWrapper(other) {}
01753
01757 inline NodeInfo GetInfo() const { return NodeInfo(xnGetNodeInfo(GetHandle())); }
01758
01762 inline XnStatus AddNeededNode(ProductionNode& needed)
01763 {
01764 return xnAddNeededNode(GetHandle(), needed.GetHandle());
01765 }
01766
01770 inline XnStatus RemoveNeededNode(ProductionNode& needed)
01771 {
01772 return xnRemoveNeededNode(GetHandle(), needed.GetHandle());
01773 }
01774
01778 inline void GetContext(Context& context) const;
01779
01783 inline XnBool IsCapabilitySupported(const XnChar* strCapabilityName) const
01784 {
01785 return xnIsCapabilitySupported(GetHandle(), strCapabilityName);
01786 }
01787
01791 inline XnStatus SetIntProperty(const XnChar* strName, XnUInt64 nValue)
01792 {
01793 return xnSetIntProperty(GetHandle(), strName, nValue);
01794 }
01795
01799 inline XnStatus SetRealProperty(const XnChar* strName, XnDouble dValue)
01800 {
01801 return xnSetRealProperty(GetHandle(), strName, dValue);
01802 }
01803
01807 inline XnStatus SetStringProperty(const XnChar* strName, const XnChar* strValue)
01808 {
01809 return xnSetStringProperty(GetHandle(), strName, strValue);
01810 }
01811
01815 inline XnStatus SetGeneralProperty(const XnChar* strName, XnUInt32 nBufferSize, const void* pBuffer)
01816 {
01817 return xnSetGeneralProperty(GetHandle(), strName, nBufferSize, pBuffer);
01818 }
01819
01823 inline XnStatus GetIntProperty(const XnChar* strName, XnUInt64& nValue) const
01824 {
01825 return xnGetIntProperty(GetHandle(), strName, &nValue);
01826 }
01827
01831 inline XnStatus GetRealProperty(const XnChar* strName, XnDouble &dValue) const
01832 {
01833 return xnGetRealProperty(GetHandle(), strName, &dValue);
01834 }
01835
01839 inline XnStatus GetStringProperty(const XnChar* strName, XnChar* csValue, XnUInt32 nBufSize) const
01840 {
01841 return xnGetStringProperty(GetHandle(), strName, csValue, nBufSize);
01842 }
01843
01847 inline XnStatus GetGeneralProperty(const XnChar* strName, XnUInt32 nBufferSize, void* pBuffer) const
01848 {
01849 return xnGetGeneralProperty(GetHandle(), strName, nBufferSize, pBuffer);
01850 }
01851
01855 inline XnStatus LockForChanges(XnLockHandle* phLock)
01856 {
01857 return xnLockNodeForChanges(GetHandle(), phLock);
01858 }
01859
01863 inline void UnlockForChanges(XnLockHandle hLock)
01864 {
01865 xnUnlockNodeForChanges(GetHandle(), hLock);
01866 }
01867
01871 inline XnStatus LockedNodeStartChanges(XnLockHandle hLock)
01872 {
01873 return xnLockedNodeStartChanges(GetHandle(), hLock);
01874 }
01875
01879 inline void LockedNodeEndChanges(XnLockHandle hLock)
01880 {
01881 xnLockedNodeEndChanges(GetHandle(), hLock);
01882 }
01883
01889 inline const ErrorStateCapability GetErrorStateCap() const
01890 {
01891 return ErrorStateCapability(GetHandle());
01892 }
01893
01899 inline ErrorStateCapability GetErrorStateCap()
01900 {
01901 return ErrorStateCapability(GetHandle());
01902 }
01903
01911 inline GeneralIntCapability GetGeneralIntCap(const XnChar* strCapability)
01912 {
01913 return GeneralIntCapability(GetHandle(), strCapability);
01914 }
01915 };
01916
01921 class DeviceIdentificationCapability : public Capability
01922 {
01923 public:
01929 DeviceIdentificationCapability(XnNodeHandle hNode) : Capability(hNode) {}
01930 DeviceIdentificationCapability(const NodeWrapper& node) : Capability(node) {}
01931
01935 inline XnStatus GetDeviceName(XnChar* strBuffer, XnUInt32 nBufferSize)
01936 {
01937 return xnGetDeviceName(GetHandle(), strBuffer, &nBufferSize);
01938 }
01939
01943 inline XnStatus GetVendorSpecificData(XnChar* strBuffer, XnUInt32 nBufferSize)
01944 {
01945 return xnGetVendorSpecificData(GetHandle(), strBuffer, &nBufferSize);
01946 }
01947
01951 inline XnStatus GetSerialNumber(XnChar* strBuffer, XnUInt32 nBufferSize)
01952 {
01953 return xnGetSerialNumber(GetHandle(), strBuffer, &nBufferSize);
01954 }
01955 };
01956
01961 class Device : public ProductionNode
01962 {
01963 public:
01969 inline Device(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {}
01970 inline Device(const NodeWrapper& other) : ProductionNode(other) {}
01971
01975 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL);
01976
01982 inline DeviceIdentificationCapability GetIdentificationCap()
01983 {
01984 return DeviceIdentificationCapability(GetHandle());
01985 }
01986 };
01987
01992 class MirrorCapability : public Capability
01993 {
01994 public:
02000 inline MirrorCapability(XnNodeHandle hNode) : Capability(hNode) {}
02001 MirrorCapability(const NodeWrapper& node) : Capability(node) {}
02002
02006 inline XnStatus SetMirror(XnBool bMirror)
02007 {
02008 return xnSetMirror(GetHandle(), bMirror);
02009 }
02010
02014 inline XnBool IsMirrored() const
02015 {
02016 return xnIsMirrored(GetHandle());
02017 }
02018
02022 inline XnStatus RegisterToMirrorChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
02023 {
02024 return _RegisterToStateChange(xnRegisterToMirrorChange, GetHandle(), handler, pCookie, hCallback);
02025 }
02026
02030 inline void UnregisterFromMirrorChange(XnCallbackHandle hCallback)
02031 {
02032 _UnregisterFromStateChange(xnUnregisterFromMirrorChange, GetHandle(), hCallback);
02033 }
02034 };
02035
02040 class AlternativeViewPointCapability : public Capability
02041 {
02042 public:
02048 inline AlternativeViewPointCapability(XnNodeHandle hNode) : Capability(hNode) {}
02049 AlternativeViewPointCapability(const NodeWrapper& node) : Capability(node) {}
02050
02054 inline XnBool IsViewPointSupported(ProductionNode& otherNode) const
02055 {
02056 return xnIsViewPointSupported(GetHandle(), otherNode.GetHandle());
02057 }
02058
02062 inline XnStatus SetViewPoint(ProductionNode& otherNode)
02063 {
02064 return xnSetViewPoint(GetHandle(), otherNode.GetHandle());
02065 }
02066
02070 inline XnStatus ResetViewPoint()
02071 {
02072 return xnResetViewPoint(GetHandle());
02073 }
02074
02078 inline XnBool IsViewPointAs(ProductionNode& otherNode) const
02079 {
02080 return xnIsViewPointAs(GetHandle(), otherNode.GetHandle());
02081 }
02082
02086 inline XnStatus RegisterToViewPointChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
02087 {
02088 return _RegisterToStateChange(xnRegisterToViewPointChange, GetHandle(), handler, pCookie, hCallback);
02089 }
02090
02094 inline void UnregisterFromViewPointChange(XnCallbackHandle hCallback)
02095 {
02096 _UnregisterFromStateChange(xnUnregisterFromViewPointChange, GetHandle(), hCallback);
02097 }
02098 };
02099
02104 class FrameSyncCapability : public Capability
02105 {
02106 public:
02112 inline FrameSyncCapability(XnNodeHandle hNode) : Capability(hNode) {}
02113 FrameSyncCapability(const NodeWrapper& node) : Capability(node) {}
02114
02118 inline XnBool CanFrameSyncWith(Generator& other) const;
02119
02123 inline XnStatus FrameSyncWith(Generator& other);
02124
02128 inline XnStatus StopFrameSyncWith(Generator& other);
02129
02133 inline XnBool IsFrameSyncedWith(Generator& other) const;
02134
02138 inline XnStatus RegisterToFrameSyncChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
02139 {
02140 return _RegisterToStateChange(xnRegisterToFrameSyncChange, GetHandle(), handler, pCookie, hCallback);
02141 }
02142
02146 inline void UnregisterFromFrameSyncChange(XnCallbackHandle hCallback)
02147 {
02148 _UnregisterFromStateChange(xnUnregisterFromFrameSyncChange, GetHandle(), hCallback);
02149 }
02150 };
02151
02156 class Generator : public ProductionNode
02157 {
02158 public:
02164 inline Generator(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {}
02165 inline Generator(const NodeWrapper& other) : ProductionNode(other) {}
02166
02170 inline XnStatus StartGenerating()
02171 {
02172 return xnStartGenerating(GetHandle());
02173 }
02174
02178 inline XnBool IsGenerating() const
02179 {
02180 return xnIsGenerating(GetHandle());
02181 }
02182
02186 inline XnStatus StopGenerating()
02187 {
02188 return xnStopGenerating(GetHandle());
02189 }
02190
02194 inline XnStatus RegisterToGenerationRunningChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle &hCallback)
02195 {
02196 return _RegisterToStateChange(xnRegisterToGenerationRunningChange, GetHandle(), handler, pCookie, hCallback);
02197 }
02198
02202 inline void UnregisterFromGenerationRunningChange(XnCallbackHandle hCallback)
02203 {
02204 _UnregisterFromStateChange(xnUnregisterFromGenerationRunningChange, GetHandle(), hCallback);
02205 }
02206
02210 inline XnStatus RegisterToNewDataAvailable(StateChangedHandler handler, void* pCookie, XnCallbackHandle &hCallback)
02211 {
02212 return _RegisterToStateChange(xnRegisterToNewDataAvailable, GetHandle(), handler, pCookie, hCallback);
02213 }
02214
02218 inline void UnregisterFromNewDataAvailable(XnCallbackHandle hCallback)
02219 {
02220 _UnregisterFromStateChange(xnUnregisterFromNewDataAvailable, GetHandle(), hCallback);
02221 }
02222
02226 inline XnBool IsNewDataAvailable(XnUInt64* pnTimestamp = NULL) const
02227 {
02228 return xnIsNewDataAvailable(GetHandle(), pnTimestamp);
02229 }
02230
02234 inline XnStatus WaitAndUpdateData()
02235 {
02236 return xnWaitAndUpdateData(GetHandle());
02237 }
02238
02242 inline XnBool IsDataNew() const
02243 {
02244 return xnIsDataNew(GetHandle());
02245 }
02246
02250 inline const void* GetData()
02251 {
02252 return xnGetData(GetHandle());
02253 }
02254
02258 inline XnUInt32 GetDataSize() const
02259 {
02260 return xnGetDataSize(GetHandle());
02261 }
02262
02266 inline XnUInt64 GetTimestamp() const
02267 {
02268 return xnGetTimestamp(GetHandle());
02269 }
02270
02274 inline XnUInt32 GetFrameID() const
02275 {
02276 return xnGetFrameID(GetHandle());
02277 }
02278
02284 inline const MirrorCapability GetMirrorCap() const
02285 {
02286 return MirrorCapability(GetHandle());
02287 }
02288
02294 inline MirrorCapability GetMirrorCap()
02295 {
02296 return MirrorCapability(GetHandle());
02297 }
02298
02304 inline const AlternativeViewPointCapability GetAlternativeViewPointCap() const
02305 {
02306 return AlternativeViewPointCapability(GetHandle());
02307 }
02308
02314 inline AlternativeViewPointCapability GetAlternativeViewPointCap()
02315 {
02316 return AlternativeViewPointCapability(GetHandle());
02317 }
02318
02324 inline const FrameSyncCapability GetFrameSyncCap() const
02325 {
02326 return FrameSyncCapability(GetHandle());
02327 }
02328
02334 inline FrameSyncCapability GetFrameSyncCap()
02335 {
02336 return FrameSyncCapability(GetHandle());
02337 }
02338 };
02339
02344 class Recorder : public ProductionNode
02345 {
02346 public:
02352 inline Recorder(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {}
02353 inline Recorder(const NodeWrapper& other) : ProductionNode(other) {}
02354
02358 inline XnStatus Create(Context& context, const XnChar* strFormatName = NULL);
02359
02363 inline XnStatus SetDestination(XnRecordMedium destType, const XnChar* strDest)
02364 {
02365 return xnSetRecorderDestination(GetHandle(), destType, strDest);
02366 }
02367
02368 inline XnStatus GetDestination(XnRecordMedium& destType, XnChar* strDest, XnUInt32 nBufSize)
02369 {
02370 return xnGetRecorderDestination(GetHandle(), &destType, strDest, nBufSize);
02371 }
02372
02376 inline XnStatus AddNodeToRecording(ProductionNode& Node, XnCodecID compression = XN_CODEC_NULL)
02377 {
02378 return xnAddNodeToRecording(GetHandle(), Node.GetHandle(), compression);
02379 }
02380
02384 inline XnStatus RemoveNodeFromRecording(ProductionNode& Node)
02385 {
02386 return xnRemoveNodeFromRecording(GetHandle(), Node.GetHandle());
02387 }
02388
02392 inline XnStatus Record()
02393 {
02394 return xnRecord(GetHandle());
02395 }
02396 };
02397
02402 class Player : public ProductionNode
02403 {
02404 public:
02410 inline Player(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {}
02411 inline Player(const NodeWrapper& other) : ProductionNode(other) {}
02412
02416 inline XnStatus Create(Context& context, const XnChar* strFormatName);
02417
02421 inline XnStatus SetRepeat(XnBool bRepeat)
02422 {
02423 return xnSetPlayerRepeat(GetHandle(), bRepeat);
02424 }
02425
02429 inline XnStatus SetSource(XnRecordMedium sourceType, const XnChar* strSource)
02430 {
02431 return xnSetPlayerSource(GetHandle(), sourceType, strSource);
02432 }
02433
02437 inline XnStatus GetSource(XnRecordMedium &sourceType, XnChar* strSource, XnUInt32 nBufSize) const
02438 {
02439 return xnGetPlayerSource(GetHandle(), &sourceType, strSource, nBufSize);
02440 }
02441
02445 inline XnStatus ReadNext()
02446 {
02447 return xnPlayerReadNext(GetHandle());
02448 }
02449
02453 inline XnStatus SeekToTimeStamp(XnInt64 nTimeOffset, XnPlayerSeekOrigin origin)
02454 {
02455 return xnSeekPlayerToTimeStamp(GetHandle(), nTimeOffset, origin);
02456 }
02457
02461 inline XnStatus SeekToFrame(const XnChar* strNodeName, XnInt32 nFrameOffset, XnPlayerSeekOrigin origin)
02462 {
02463 return xnSeekPlayerToFrame(GetHandle(), strNodeName, nFrameOffset, origin);
02464 }
02465
02469 inline XnStatus TellTimestamp(XnUInt64& nTimestamp) const
02470 {
02471 return xnTellPlayerTimestamp(GetHandle(), &nTimestamp);
02472 }
02473
02477 inline XnStatus TellFrame(const XnChar* strNodeName, XnUInt32& nFrame) const
02478 {
02479 return xnTellPlayerFrame(GetHandle(), strNodeName, &nFrame);
02480 }
02481
02485 inline XnStatus GetNumFrames(const XnChar* strNodeName, XnUInt32& nFrames) const
02486 {
02487 return xnGetPlayerNumFrames(GetHandle(), strNodeName, &nFrames);
02488 }
02489
02493 inline const XnChar* GetSupportedFormat() const
02494 {
02495 return xnGetPlayerSupportedFormat(GetHandle());
02496 }
02497
02501 inline XnStatus EnumerateNodes(NodeInfoList& list) const
02502 {
02503 XnNodeInfoList* pList;
02504 XnStatus nRetVal = xnEnumeratePlayerNodes(GetHandle(), &pList);
02505 XN_IS_STATUS_OK(nRetVal);
02506
02507 list.ReplaceUnderlyingObject(pList);
02508
02509 return (XN_STATUS_OK);
02510 }
02511
02515 inline XnBool IsEOF() const
02516 {
02517 return xnIsPlayerAtEOF(GetHandle());
02518 }
02519
02523 inline XnStatus RegisterToEndOfFileReached(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
02524 {
02525 return _RegisterToStateChange(xnRegisterToEndOfFileReached, GetHandle(), handler, pCookie, hCallback);
02526 }
02527
02531 inline void UnregisterFromEndOfFileReached(XnCallbackHandle hCallback)
02532 {
02533 _UnregisterFromStateChange(xnUnregisterFromEndOfFileReached, GetHandle(), hCallback);
02534 }
02535
02539 inline XnStatus SetPlaybackSpeed(XnDouble dSpeed)
02540 {
02541 return xnSetPlaybackSpeed(GetHandle(), dSpeed);
02542 }
02543
02547 inline XnDouble GetPlaybackSpeed() const
02548 {
02549 return xnGetPlaybackSpeed(GetHandle());
02550 }
02551 };
02552
02557 class CroppingCapability : public Capability
02558 {
02559 public:
02565 inline CroppingCapability(XnNodeHandle hNode) : Capability(hNode) {}
02566 CroppingCapability(const NodeWrapper& node) : Capability(node) {}
02567
02571 inline XnStatus SetCropping(const XnCropping& Cropping)
02572 {
02573 return xnSetCropping(GetHandle(), &Cropping);
02574 }
02575
02579 inline XnStatus GetCropping(XnCropping& Cropping) const
02580 {
02581 return xnGetCropping(GetHandle(), &Cropping);
02582 }
02583
02587 inline XnStatus RegisterToCroppingChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
02588 {
02589 return _RegisterToStateChange(xnRegisterToCroppingChange, GetHandle(), handler, pCookie, hCallback);
02590 }
02591
02595 inline void UnregisterFromCroppingChange(XnCallbackHandle hCallback)
02596 {
02597 _UnregisterFromStateChange(xnUnregisterFromCroppingChange, GetHandle(), hCallback);
02598 }
02599 };
02600
02605 class AntiFlickerCapability : public Capability
02606 {
02607 public:
02613 inline AntiFlickerCapability(XnNodeHandle hNode) : Capability(hNode) {}
02614 AntiFlickerCapability(const NodeWrapper& node) : Capability(node) {}
02615
02619 inline XnStatus SetPowerLineFrequency(XnPowerLineFrequency nFrequency)
02620 {
02621 return xnSetPowerLineFrequency(GetHandle(), nFrequency);
02622 }
02623
02627 inline XnPowerLineFrequency GetPowerLineFrequency()
02628 {
02629 return xnGetPowerLineFrequency(GetHandle());
02630 }
02631
02635 inline XnStatus RegisterToPowerLineFrequencyChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
02636 {
02637 return _RegisterToStateChange(xnRegisterToPowerLineFrequencyChange, GetHandle(), handler, pCookie, hCallback);
02638 }
02639
02643 inline void UnregisterFromPowerLineFrequencyChange(XnCallbackHandle hCallback)
02644 {
02645 _UnregisterFromStateChange(xnUnregisterFromPowerLineFrequencyChange, GetHandle(), hCallback);
02646 }
02647 };
02648
02653 class MapGenerator : public Generator
02654 {
02655 public:
02661 inline MapGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {}
02662 inline MapGenerator(const NodeWrapper& other) : Generator(other) {}
02663
02667 inline XnUInt32 GetSupportedMapOutputModesCount() const
02668 {
02669 return xnGetSupportedMapOutputModesCount(GetHandle());
02670 }
02671
02675 inline XnStatus GetSupportedMapOutputModes(XnMapOutputMode* aModes, XnUInt32& nCount) const
02676 {
02677 return xnGetSupportedMapOutputModes(GetHandle(), aModes, &nCount);
02678 }
02679
02683 inline XnStatus SetMapOutputMode(const XnMapOutputMode& OutputMode)
02684 {
02685 return xnSetMapOutputMode(GetHandle(), &OutputMode);
02686 }
02687
02691 inline XnStatus GetMapOutputMode(XnMapOutputMode &OutputMode) const
02692 {
02693 return xnGetMapOutputMode(GetHandle(), &OutputMode);
02694 }
02695
02699 inline XnUInt32 GetBytesPerPixel() const
02700 {
02701 return xnGetBytesPerPixel(GetHandle());
02702 }
02703
02707 inline XnStatus RegisterToMapOutputModeChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
02708 {
02709 return _RegisterToStateChange(xnRegisterToMapOutputModeChange, GetHandle(), handler, pCookie, hCallback);
02710 }
02711
02715 inline void UnregisterFromMapOutputModeChange(XnCallbackHandle hCallback)
02716 {
02717 _UnregisterFromStateChange(xnUnregisterFromMapOutputModeChange, GetHandle(), hCallback);
02718 }
02719
02725 inline const CroppingCapability GetCroppingCap() const
02726 {
02727 return CroppingCapability(GetHandle());
02728 }
02729
02735 inline CroppingCapability GetCroppingCap()
02736 {
02737 return CroppingCapability(GetHandle());
02738 }
02739
02745 inline GeneralIntCapability GetBrightnessCap()
02746 {
02747 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_BRIGHTNESS);
02748 }
02749
02755 inline GeneralIntCapability GetContrastCap()
02756 {
02757 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_CONTRAST);
02758 }
02759
02765 inline GeneralIntCapability GetHueCap()
02766 {
02767 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_HUE);
02768 }
02769
02775 inline GeneralIntCapability GetSaturationCap()
02776 {
02777 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_SATURATION);
02778 }
02779
02785 inline GeneralIntCapability GetSharpnessCap()
02786 {
02787 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_SHARPNESS);
02788 }
02789
02795 inline GeneralIntCapability GetGammaCap()
02796 {
02797 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_GAMMA);
02798 }
02799
02805 inline GeneralIntCapability GetWhiteBalanceCap()
02806 {
02807 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_COLOR_TEMPERATURE);
02808 }
02809
02815 inline GeneralIntCapability GetBacklightCompensationCap()
02816 {
02817 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_BACKLIGHT_COMPENSATION);
02818 }
02819
02825 inline GeneralIntCapability GetGainCap()
02826 {
02827 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_GAIN);
02828 }
02829
02835 inline GeneralIntCapability GetPanCap()
02836 {
02837 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_PAN);
02838 }
02839
02845 inline GeneralIntCapability GetTiltCap()
02846 {
02847 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_TILT);
02848 }
02849
02855 inline GeneralIntCapability GetRollCap()
02856 {
02857 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_ROLL);
02858 }
02859
02865 inline GeneralIntCapability GetZoomCap()
02866 {
02867 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_ZOOM);
02868 }
02869
02875 inline GeneralIntCapability GetExposureCap()
02876 {
02877 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_EXPOSURE);
02878 }
02879
02885 inline GeneralIntCapability GetIrisCap()
02886 {
02887 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_IRIS);
02888 }
02889
02895 inline GeneralIntCapability GetFocusCap()
02896 {
02897 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_FOCUS);
02898 }
02899
02905 inline GeneralIntCapability GetLowLightCompensationCap()
02906 {
02907 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_LOW_LIGHT_COMPENSATION);
02908 }
02909
02915 inline AntiFlickerCapability GetAntiFlickerCap()
02916 {
02917 return AntiFlickerCapability(GetHandle());
02918 }
02919 };
02920
02925 class UserPositionCapability : public Capability
02926 {
02927 public:
02933 inline UserPositionCapability(XnNodeHandle hNode = NULL) : Capability(hNode) {}
02934 UserPositionCapability(const NodeWrapper& node) : Capability(node) {}
02935
02939 inline XnUInt32 GetSupportedUserPositionsCount() const
02940 {
02941 return xnGetSupportedUserPositionsCount(GetHandle());
02942 }
02943
02947 inline XnStatus SetUserPosition(XnUInt32 nIndex, const XnBoundingBox3D& Position)
02948 {
02949 return xnSetUserPosition(GetHandle(), nIndex, &Position);
02950 }
02951
02955 inline XnStatus GetUserPosition(XnUInt32 nIndex, XnBoundingBox3D& Position) const
02956 {
02957 return xnGetUserPosition(GetHandle(), nIndex, &Position);
02958 }
02959
02963 inline XnStatus RegisterToUserPositionChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
02964 {
02965 return _RegisterToStateChange(xnRegisterToUserPositionChange, GetHandle(), handler, pCookie, hCallback);
02966 }
02967
02971 inline void UnregisterFromUserPositionChange(XnCallbackHandle hCallback)
02972 {
02973 _UnregisterFromStateChange(xnUnregisterFromUserPositionChange, GetHandle(), hCallback);
02974 }
02975 };
02976
02981 class DepthGenerator : public MapGenerator
02982 {
02983 public:
02989 inline DepthGenerator(XnNodeHandle hNode = NULL) : MapGenerator(hNode) {}
02990 inline DepthGenerator(const NodeWrapper& other) : MapGenerator(other) {}
02991
02995 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL);
02996
03000 inline void GetMetaData(DepthMetaData& metaData) const
03001 {
03002 xnGetDepthMetaData(GetHandle(), metaData.GetUnderlying());
03003 }
03004
03008 inline const XnDepthPixel* GetDepthMap() const
03009 {
03010 return xnGetDepthMap(GetHandle());
03011 }
03012
03016 inline XnDepthPixel GetDeviceMaxDepth() const
03017 {
03018 return xnGetDeviceMaxDepth(GetHandle());
03019 }
03020
03024 inline XnStatus GetFieldOfView(XnFieldOfView& FOV) const
03025 {
03026 return xnGetDepthFieldOfView(GetHandle(), &FOV);
03027 }
03028
03032 inline XnStatus RegisterToFieldOfViewChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
03033 {
03034 return _RegisterToStateChange(xnRegisterToDepthFieldOfViewChange, GetHandle(), handler, pCookie, hCallback);
03035 }
03036
03040 inline void UnregisterFromFieldOfViewChange(XnCallbackHandle hCallback)
03041 {
03042 _UnregisterFromStateChange(xnUnregisterFromDepthFieldOfViewChange, GetHandle(), hCallback);
03043 }
03044
03048 inline XnStatus ConvertProjectiveToRealWorld(XnUInt32 nCount, const XnPoint3D aProjective[], XnPoint3D aRealWorld[]) const
03049 {
03050 return xnConvertProjectiveToRealWorld(GetHandle(), nCount, aProjective, aRealWorld);
03051 }
03052
03056 inline XnStatus ConvertRealWorldToProjective(XnUInt32 nCount, const XnPoint3D aRealWorld[], XnPoint3D aProjective[]) const
03057 {
03058 return xnConvertRealWorldToProjective(GetHandle(), nCount, aRealWorld, aProjective);
03059 }
03060
03066 inline const UserPositionCapability GetUserPositionCap() const
03067 {
03068 return UserPositionCapability(GetHandle());
03069 }
03070
03076 inline UserPositionCapability GetUserPositionCap()
03077 {
03078 return UserPositionCapability(GetHandle());
03079 }
03080 };
03081
03086 class MockDepthGenerator : public DepthGenerator
03087 {
03088 public:
03094 inline MockDepthGenerator(XnNodeHandle hNode = NULL) : DepthGenerator(hNode) {}
03095 inline MockDepthGenerator(const NodeWrapper& other) : DepthGenerator(other) {}
03096
03103 XnStatus Create(Context& context, const XnChar* strName = NULL);
03104
03111 XnStatus CreateBasedOn(DepthGenerator& other, const XnChar* strName = NULL);
03112
03116 inline XnStatus SetData(XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize, const XnDepthPixel* pDepthMap)
03117 {
03118 return xnMockDepthSetData(GetHandle(), nFrameID, nTimestamp, nDataSize, pDepthMap);
03119 }
03120
03128 inline XnStatus SetData(const DepthMetaData& depthMD, XnUInt32 nFrameID, XnUInt64 nTimestamp)
03129 {
03130 return SetData(nFrameID, nTimestamp, depthMD.DataSize(), depthMD.Data());
03131 }
03132
03138 inline XnStatus SetData(const DepthMetaData& depthMD)
03139 {
03140 return SetData(depthMD, depthMD.FrameID(), depthMD.Timestamp());
03141 }
03142 };
03143
03148 class ImageGenerator : public MapGenerator
03149 {
03150 public:
03156 inline ImageGenerator(XnNodeHandle hNode = NULL) : MapGenerator(hNode) {}
03157 inline ImageGenerator(const NodeWrapper& other) : MapGenerator(other) {}
03158
03162 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL);
03163
03167 inline void GetMetaData(ImageMetaData& metaData) const
03168 {
03169 xnGetImageMetaData(GetHandle(), metaData.GetUnderlying());
03170 }
03171
03175 inline const XnRGB24Pixel* GetRGB24ImageMap() const
03176 {
03177 return xnGetRGB24ImageMap(GetHandle());
03178 }
03179
03183 inline const XnYUV422DoublePixel* GetYUV422ImageMap() const
03184 {
03185 return xnGetYUV422ImageMap(GetHandle());
03186 }
03187
03191 inline const XnGrayscale8Pixel* GetGrayscale8ImageMap() const
03192 {
03193 return xnGetGrayscale8ImageMap(GetHandle());
03194 }
03195
03199 inline const XnGrayscale16Pixel* GetGrayscale16ImageMap() const
03200 {
03201 return xnGetGrayscale16ImageMap(GetHandle());
03202 }
03203
03207 inline const XnUInt8* GetImageMap() const
03208 {
03209 return xnGetImageMap(GetHandle());
03210 }
03211
03215 inline XnBool IsPixelFormatSupported(XnPixelFormat Format) const
03216 {
03217 return xnIsPixelFormatSupported(GetHandle(), Format);
03218 }
03219
03223 inline XnStatus SetPixelFormat(XnPixelFormat Format)
03224 {
03225 return xnSetPixelFormat(GetHandle(), Format);
03226 }
03227
03231 inline XnPixelFormat GetPixelFormat() const
03232 {
03233 return xnGetPixelFormat(GetHandle());
03234 }
03235
03239 inline XnStatus RegisterToPixelFormatChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
03240 {
03241 return _RegisterToStateChange(xnRegisterToPixelFormatChange, GetHandle(), handler, pCookie, hCallback);
03242 }
03243
03247 inline void UnregisterFromPixelFormatChange(XnCallbackHandle hCallback)
03248 {
03249 _UnregisterFromStateChange(xnUnregisterFromPixelFormatChange, GetHandle(), hCallback);
03250 }
03251 };
03252
03257 class MockImageGenerator : public ImageGenerator
03258 {
03259 public:
03265 inline MockImageGenerator(XnNodeHandle hNode = NULL) : ImageGenerator(hNode) {}
03266 inline MockImageGenerator(const NodeWrapper& other) : ImageGenerator(other) {}
03267
03274 XnStatus Create(Context& context, const XnChar* strName = NULL);
03275
03282 XnStatus CreateBasedOn(ImageGenerator& other, const XnChar* strName = NULL);
03283
03287 inline XnStatus SetData(XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize, const XnUInt8* pImageMap)
03288 {
03289 return xnMockImageSetData(GetHandle(), nFrameID, nTimestamp, nDataSize, pImageMap);
03290 }
03291
03299 inline XnStatus SetData(const ImageMetaData& imageMD, XnUInt32 nFrameID, XnUInt64 nTimestamp)
03300 {
03301 return SetData(nFrameID, nTimestamp, imageMD.DataSize(), imageMD.Data());
03302 }
03303
03309 inline XnStatus SetData(const ImageMetaData& imageMD)
03310 {
03311 return SetData(imageMD, imageMD.FrameID(), imageMD.Timestamp());
03312 }
03313 };
03314
03319 class IRGenerator : public MapGenerator
03320 {
03321 public:
03327 inline IRGenerator(XnNodeHandle hNode = NULL) : MapGenerator(hNode) {}
03328 inline IRGenerator(const NodeWrapper& other) : MapGenerator(other) {}
03329
03333 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL);
03334
03338 inline void GetMetaData(IRMetaData& metaData) const
03339 {
03340 xnGetIRMetaData(GetHandle(), metaData.GetUnderlying());
03341 }
03342
03346 inline const XnIRPixel* GetIRMap() const
03347 {
03348 return xnGetIRMap(GetHandle());
03349 }
03350 };
03351
03356 class MockIRGenerator : public IRGenerator
03357 {
03358 public:
03364 inline MockIRGenerator(XnNodeHandle hNode = NULL) : IRGenerator(hNode) {}
03365 inline MockIRGenerator(const NodeWrapper& other) : IRGenerator(other) {}
03366
03373 XnStatus Create(Context& context, const XnChar* strName = NULL);
03380 XnStatus CreateBasedOn(IRGenerator& other, const XnChar* strName = NULL);
03381
03385 inline XnStatus SetData(XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize, const XnIRPixel* pIRMap)
03386 {
03387 return xnMockIRSetData(GetHandle(), nFrameID, nTimestamp, nDataSize, pIRMap);
03388 }
03389
03397 inline XnStatus SetData(const IRMetaData& irMD, XnUInt32 nFrameID, XnUInt64 nTimestamp)
03398 {
03399 return SetData(nFrameID, nTimestamp, irMD.DataSize(), irMD.Data());
03400 }
03401
03407 inline XnStatus SetData(const IRMetaData& irMD)
03408 {
03409 return SetData(irMD, irMD.FrameID(), irMD.Timestamp());
03410 }
03411 };
03412
03417 class GestureGenerator : public Generator
03418 {
03419 public:
03425 inline GestureGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {}
03426 inline GestureGenerator(const NodeWrapper& other) : Generator(other) {}
03427
03431 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL);
03432
03436 inline XnStatus AddGesture(const XnChar* strGesture, XnBoundingBox3D* pArea)
03437 {
03438 return xnAddGesture(GetHandle(), strGesture, pArea);
03439 }
03440
03444 inline XnStatus RemoveGesture(const XnChar* strGesture)
03445 {
03446 return xnRemoveGesture(GetHandle(), strGesture);
03447 }
03448
03452 inline XnStatus GetActiveGestures(XnChar*& astrGestures, XnUInt16& nGestures) const
03453 {
03454 return xnGetActiveGestures(GetHandle(), &astrGestures, &nGestures);
03455 }
03456
03460 inline XnStatus GetAllActiveGestures(XnChar** astrGestures, XnUInt32 nNameLength, XnUInt16& nGestures) const
03461 {
03462 return xnGetAllActiveGestures(GetHandle(), astrGestures, nNameLength, &nGestures);
03463 }
03464
03468 inline XnStatus EnumerateGestures(XnChar*& astrGestures, XnUInt16& nGestures) const
03469 {
03470 return xnEnumerateGestures(GetHandle(), &astrGestures, &nGestures);
03471 }
03475 inline XnStatus EnumerateAllGestures(XnChar** astrGestures, XnUInt32 nNameLength, XnUInt16& nGestures) const
03476 {
03477 return xnEnumerateAllGestures(GetHandle(), astrGestures, nNameLength, &nGestures);
03478 }
03479
03483 inline XnBool IsGestureAvailable(const XnChar* strGesture) const
03484 {
03485 return xnIsGestureAvailable(GetHandle(), strGesture);
03486 }
03487
03491 inline XnBool IsGestureProgressSupported(const XnChar* strGesture) const
03492 {
03493 return xnIsGestureProgressSupported(GetHandle(), strGesture);
03494 }
03495
03505 typedef void (XN_CALLBACK_TYPE* GestureRecognized)(GestureGenerator& generator, const XnChar* strGesture, const XnPoint3D* pIDPosition, const XnPoint3D* pEndPosition, void* pCookie);
03515 typedef void (XN_CALLBACK_TYPE* GestureProgress)(GestureGenerator& generator, const XnChar* strGesture, const XnPoint3D* pPosition, XnFloat fProgress, void* pCookie);
03516
03520 XnStatus RegisterGestureCallbacks(GestureRecognized RecognizedCB, GestureProgress ProgressCB, void* pCookie, XnCallbackHandle& hCallback)
03521 {
03522 XnStatus nRetVal = XN_STATUS_OK;
03523
03524 GestureCookie* pGestureCookie;
03525 XN_VALIDATE_ALLOC(pGestureCookie, GestureCookie);
03526 pGestureCookie->recognizedHandler = RecognizedCB;
03527 pGestureCookie->progressHandler = ProgressCB;
03528 pGestureCookie->pUserCookie = pCookie;
03529
03530 nRetVal = xnRegisterGestureCallbacks(GetHandle(), GestureRecognizedCallback, GestureProgressCallback, pGestureCookie, &pGestureCookie->hCallback);
03531 if (nRetVal != XN_STATUS_OK)
03532 {
03533 xnOSFree(pGestureCookie);
03534 return (nRetVal);
03535 }
03536
03537 hCallback = pGestureCookie;
03538
03539 return (XN_STATUS_OK);
03540 }
03541
03545 inline void UnregisterGestureCallbacks(XnCallbackHandle hCallback)
03546 {
03547 GestureCookie* pGestureCookie = (GestureCookie*)hCallback;
03548 xnUnregisterGestureCallbacks(GetHandle(), pGestureCookie->hCallback);
03549 xnOSFree(pGestureCookie);
03550 }
03551
03555 inline XnStatus RegisterToGestureChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
03556 {
03557 return _RegisterToStateChange(xnRegisterToGestureChange, GetHandle(), handler, pCookie, hCallback);
03558 }
03559
03563 inline void UnregisterFromGestureChange(XnCallbackHandle hCallback)
03564 {
03565 _UnregisterFromStateChange(xnUnregisterFromGestureChange, GetHandle(), hCallback);
03566 }
03567
03576 typedef void (XN_CALLBACK_TYPE* GestureIntermediateStageCompleted)(GestureGenerator& generator, const XnChar* strGesture, const XnPoint3D* pPosition, void* pCookie);
03580 XnStatus RegisterToGestureIntermediateStageCompleted(GestureIntermediateStageCompleted handler, void* pCookie, XnCallbackHandle& hCallback)
03581 {
03582 XnStatus nRetVal = XN_STATUS_OK;
03583
03584 GestureIntermediateStageCompletedCookie* pGestureCookie;
03585 XN_VALIDATE_ALLOC(pGestureCookie, GestureIntermediateStageCompletedCookie);
03586 pGestureCookie->handler = handler;
03587 pGestureCookie->pUserCookie = pCookie;
03588
03589 nRetVal = xnRegisterToGestureIntermediateStageCompleted(GetHandle(), GestureIntermediateStageCompletedCallback, pGestureCookie, &pGestureCookie->hCallback);
03590 if (nRetVal != XN_STATUS_OK)
03591 {
03592 xnOSFree(pGestureCookie);
03593 return (nRetVal);
03594 }
03595
03596 hCallback = pGestureCookie;
03597
03598 return (XN_STATUS_OK);
03599 }
03603 inline void UnregisterFromGestureIntermediateStageCompleted(XnCallbackHandle hCallback)
03604 {
03605 GestureIntermediateStageCompletedCookie* pGestureCookie = (GestureIntermediateStageCompletedCookie*)hCallback;
03606 xnUnregisterFromGestureIntermediateStageCompleted(GetHandle(), pGestureCookie->hCallback);
03607 xnOSFree(pGestureCookie);
03608 }
03609
03618 typedef void (XN_CALLBACK_TYPE* GestureReadyForNextIntermediateStage)(GestureGenerator& generator, const XnChar* strGesture, const XnPoint3D* pPosition, void* pCookie);
03622 XnStatus RegisterToGestureReadyForNextIntermediateStage(GestureReadyForNextIntermediateStage handler, void* pCookie, XnCallbackHandle& hCallback)
03623 {
03624 XnStatus nRetVal = XN_STATUS_OK;
03625
03626 GestureReadyForNextIntermediateStageCookie* pGestureCookie;
03627 XN_VALIDATE_ALLOC(pGestureCookie, GestureReadyForNextIntermediateStageCookie);
03628 pGestureCookie->handler = handler;
03629 pGestureCookie->pUserCookie = pCookie;
03630
03631 nRetVal = xnRegisterToGestureReadyForNextIntermediateStage(GetHandle(), GestureReadyForNextIntermediateStageCallback, pGestureCookie, &pGestureCookie->hCallback);
03632 if (nRetVal != XN_STATUS_OK)
03633 {
03634 xnOSFree(pGestureCookie);
03635 return (nRetVal);
03636 }
03637
03638 hCallback = pGestureCookie;
03639
03640 return (XN_STATUS_OK);
03641 }
03642
03646 inline void UnregisterFromGestureReadyForNextIntermediateStageCallbacks(XnCallbackHandle hCallback)
03647 {
03648 GestureReadyForNextIntermediateStageCookie* pGestureCookie = (GestureReadyForNextIntermediateStageCookie*)hCallback;
03649 xnUnregisterFromGestureReadyForNextIntermediateStage(GetHandle(), pGestureCookie->hCallback);
03650 xnOSFree(pGestureCookie);
03651 }
03652
03653 private:
03654 typedef struct GestureCookie
03655 {
03656 GestureRecognized recognizedHandler;
03657 GestureProgress progressHandler;
03658 void* pUserCookie;
03659 XnCallbackHandle hCallback;
03660 } GestureCookie;
03661
03662 static void XN_CALLBACK_TYPE GestureRecognizedCallback(XnNodeHandle hNode, const XnChar* strGesture, const XnPoint3D* pIDPosition, const XnPoint3D* pEndPosition, void* pCookie)
03663 {
03664 GestureCookie* pGestureCookie = (GestureCookie*)pCookie;
03665 GestureGenerator gen(hNode);
03666 if (pGestureCookie->recognizedHandler != NULL)
03667 {
03668 pGestureCookie->recognizedHandler(gen, strGesture, pIDPosition, pEndPosition, pGestureCookie->pUserCookie);
03669 }
03670 }
03671
03672 static void XN_CALLBACK_TYPE GestureProgressCallback(XnNodeHandle hNode, const XnChar* strGesture, const XnPoint3D* pPosition, XnFloat fProgress, void* pCookie)
03673 {
03674 GestureCookie* pGestureCookie = (GestureCookie*)pCookie;
03675 GestureGenerator gen(hNode);
03676 if (pGestureCookie->progressHandler != NULL)
03677 {
03678 pGestureCookie->progressHandler(gen, strGesture, pPosition, fProgress, pGestureCookie->pUserCookie);
03679 }
03680 }
03681
03682 typedef struct GestureIntermediateStageCompletedCookie
03683 {
03684 GestureIntermediateStageCompleted handler;
03685 void* pUserCookie;
03686 XnCallbackHandle hCallback;
03687 } GestureIntermediateStageCompletedCookie;
03688
03689 static void XN_CALLBACK_TYPE GestureIntermediateStageCompletedCallback(XnNodeHandle hNode, const XnChar* strGesture, const XnPoint3D* pPosition, void* pCookie)
03690 {
03691 GestureIntermediateStageCompletedCookie* pGestureCookie = (GestureIntermediateStageCompletedCookie*)pCookie;
03692 GestureGenerator gen(hNode);
03693 if (pGestureCookie->handler != NULL)
03694 {
03695 pGestureCookie->handler(gen, strGesture, pPosition, pGestureCookie->pUserCookie);
03696 }
03697 }
03698
03699 typedef struct GestureReadyForNextIntermediateStageCookie
03700 {
03701 GestureReadyForNextIntermediateStage handler;
03702 void* pUserCookie;
03703 XnCallbackHandle hCallback;
03704 } GestureReadyForNextIntermediateStageCookie;
03705
03706 static void XN_CALLBACK_TYPE GestureReadyForNextIntermediateStageCallback(XnNodeHandle hNode, const XnChar* strGesture, const XnPoint3D* pPosition, void* pCookie)
03707 {
03708 GestureReadyForNextIntermediateStageCookie* pGestureCookie = (GestureReadyForNextIntermediateStageCookie*)pCookie;
03709 GestureGenerator gen(hNode);
03710 if (pGestureCookie->handler != NULL)
03711 {
03712 pGestureCookie->handler(gen, strGesture, pPosition, pGestureCookie->pUserCookie);
03713 }
03714 }
03715 };
03716
03721 class SceneAnalyzer : public MapGenerator
03722 {
03723 public:
03729 inline SceneAnalyzer(XnNodeHandle hNode = NULL) : MapGenerator(hNode) {}
03730 inline SceneAnalyzer(const NodeWrapper& other) : MapGenerator(other) {}
03731
03735 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL);
03736
03740 inline void GetMetaData(SceneMetaData& metaData) const
03741 {
03742 xnGetSceneMetaData(GetHandle(), metaData.GetUnderlying());
03743 }
03744
03748 inline const XnLabel* GetLabelMap() const
03749 {
03750 return xnGetLabelMap(GetHandle());
03751 }
03752
03756 inline XnStatus GetFloor(XnPlane3D& Plane) const
03757 {
03758 return xnGetFloor(GetHandle(), &Plane);
03759 }
03760 };
03761
03766 class HandTouchingFOVEdgeCapability : public Capability
03767 {
03768 public:
03774 inline HandTouchingFOVEdgeCapability(XnNodeHandle hNode) : Capability(hNode) {}
03775 HandTouchingFOVEdgeCapability(const NodeWrapper& node) : Capability(node) {}
03776
03787 typedef void (XN_CALLBACK_TYPE* HandTouchingFOVEdge)(HandTouchingFOVEdgeCapability& touchingfov, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, XnDirection eDir, void* pCookie);
03791 inline XnStatus RegisterToHandTouchingFOVEdge(HandTouchingFOVEdge handler, void* pCookie, XnCallbackHandle& hCallback)
03792 {
03793 XnStatus nRetVal = XN_STATUS_OK;
03794
03795 HandTouchingFOVEdgeCookie* pHandCookie;
03796 XN_VALIDATE_ALLOC(pHandCookie, HandTouchingFOVEdgeCookie);
03797 pHandCookie->handler = handler;
03798 pHandCookie->pUserCookie = pCookie;
03799
03800 nRetVal = xnRegisterToHandTouchingFOVEdge(GetHandle(), HandTouchingFOVEdgeCB, pHandCookie, &pHandCookie->hCallback);
03801 if (nRetVal != XN_STATUS_OK)
03802 {
03803 xnOSFree(pHandCookie);
03804 return (nRetVal);
03805 }
03806
03807 hCallback = pHandCookie;
03808
03809 return (XN_STATUS_OK);
03810 }
03811
03815 inline void UnregisterFromHandTouchingFOVEdge(XnCallbackHandle hCallback)
03816 {
03817 HandTouchingFOVEdgeCookie* pHandCookie = (HandTouchingFOVEdgeCookie*)hCallback;
03818 xnUnregisterFromHandTouchingFOVEdge(GetHandle(), pHandCookie->hCallback);
03819 xnOSFree(pHandCookie);
03820 }
03821 private:
03822 typedef struct HandTouchingFOVEdgeCookie
03823 {
03824 HandTouchingFOVEdge handler;
03825 void* pUserCookie;
03826 XnCallbackHandle hCallback;
03827 } HandTouchingFOVEdgeCookie;
03828
03829 static void XN_CALLBACK_TYPE HandTouchingFOVEdgeCB(XnNodeHandle hNode, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, XnDirection eDir, void* pCookie)
03830 {
03831 HandTouchingFOVEdgeCookie* pHandCookie = (HandTouchingFOVEdgeCookie*)pCookie;
03832 HandTouchingFOVEdgeCapability cap(hNode);
03833 if (pHandCookie->handler != NULL)
03834 {
03835 pHandCookie->handler(cap, user, pPosition, fTime, eDir, pHandCookie->pUserCookie);
03836 }
03837 }
03838
03839 };
03844 class HandsGenerator : public Generator
03845 {
03846 public:
03852 inline HandsGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {}
03853 inline HandsGenerator(const NodeWrapper& other) : Generator(other) {}
03854
03858 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL);
03859
03869 typedef void (XN_CALLBACK_TYPE* HandCreate)(HandsGenerator& generator, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, void* pCookie);
03879 typedef void (XN_CALLBACK_TYPE* HandUpdate)(HandsGenerator& generator, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, void* pCookie);
03888 typedef void (XN_CALLBACK_TYPE* HandDestroy)(HandsGenerator& generator, XnUserID user, XnFloat fTime, void* pCookie);
03889
03893 inline XnStatus RegisterHandCallbacks(HandCreate CreateCB, HandUpdate UpdateCB, HandDestroy DestroyCB, void* pCookie, XnCallbackHandle& hCallback)
03894 {
03895 XnStatus nRetVal = XN_STATUS_OK;
03896
03897 HandCookie* pHandCookie;
03898 XN_VALIDATE_ALLOC(pHandCookie, HandCookie);
03899 pHandCookie->createHandler = CreateCB;
03900 pHandCookie->updateHandler = UpdateCB;
03901 pHandCookie->destroyHandler = DestroyCB;
03902 pHandCookie->pUserCookie = pCookie;
03903
03904 nRetVal = xnRegisterHandCallbacks(GetHandle(), HandCreateCB, HandUpdateCB, HandDestroyCB, pHandCookie, &pHandCookie->hCallback);
03905 if (nRetVal != XN_STATUS_OK)
03906 {
03907 xnOSFree(pHandCookie);
03908 return (nRetVal);
03909 }
03910
03911 hCallback = pHandCookie;
03912
03913 return (XN_STATUS_OK);
03914 }
03915
03919 inline void UnregisterHandCallbacks(XnCallbackHandle hCallback)
03920 {
03921 HandCookie* pHandCookie = (HandCookie*)hCallback;
03922 xnUnregisterHandCallbacks(GetHandle(), pHandCookie->hCallback);
03923 xnOSFree(pHandCookie);
03924 }
03925
03929 inline XnStatus StopTracking(XnUserID user)
03930 {
03931 return xnStopTracking(GetHandle(), user);
03932 }
03933
03937 inline XnStatus StopTrackingAll()
03938 {
03939 return xnStopTrackingAll(GetHandle());
03940 }
03941
03945 inline XnStatus StartTracking(const XnPoint3D& ptPosition)
03946 {
03947 return xnStartTracking(GetHandle(), &ptPosition);
03948 }
03949
03953 inline XnStatus SetSmoothing(XnFloat fSmoothingFactor)
03954 {
03955 return xnSetTrackingSmoothing(GetHandle(), fSmoothingFactor);
03956 }
03957
03963 inline const HandTouchingFOVEdgeCapability GetHandTouchingFOVEdgeCap() const
03964 {
03965 return HandTouchingFOVEdgeCapability(GetHandle());
03966 }
03967
03973 inline HandTouchingFOVEdgeCapability GetHandTouchingFOVEdgeCap()
03974 {
03975 return HandTouchingFOVEdgeCapability(GetHandle());
03976 }
03977
03978 private:
03979 typedef struct HandCookie
03980 {
03981 HandCreate createHandler;
03982 HandUpdate updateHandler;
03983 HandDestroy destroyHandler;
03984 void* pUserCookie;
03985 XnCallbackHandle hCallback;
03986 } HandCookie;
03987
03988 static void XN_CALLBACK_TYPE HandCreateCB(XnNodeHandle hNode, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, void* pCookie)
03989 {
03990 HandCookie* pHandCookie = (HandCookie*)pCookie;
03991 HandsGenerator gen(hNode);
03992 if (pHandCookie->createHandler != NULL)
03993 {
03994 pHandCookie->createHandler(gen, user, pPosition, fTime, pHandCookie->pUserCookie);
03995 }
03996 }
03997 static void XN_CALLBACK_TYPE HandUpdateCB(XnNodeHandle hNode, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, void* pCookie)
03998 {
03999 HandCookie* pHandCookie = (HandCookie*)pCookie;
04000 HandsGenerator gen(hNode);
04001 if (pHandCookie->updateHandler != NULL)
04002 {
04003 pHandCookie->updateHandler(gen, user, pPosition, fTime, pHandCookie->pUserCookie);
04004 }
04005 }
04006 static void XN_CALLBACK_TYPE HandDestroyCB(XnNodeHandle hNode, XnUserID user, XnFloat fTime, void* pCookie)
04007 {
04008 HandCookie* pHandCookie = (HandCookie*)pCookie;
04009 HandsGenerator gen(hNode);
04010 if (pHandCookie->destroyHandler != NULL)
04011 {
04012 pHandCookie->destroyHandler(gen, user, fTime, pHandCookie->pUserCookie);
04013 }
04014 }
04015 };
04016
04021 class SkeletonCapability : public Capability
04022 {
04023 public:
04029 inline SkeletonCapability(XnNodeHandle hNode) : Capability(hNode) {}
04030 SkeletonCapability(const NodeWrapper& node) : Capability(node) {}
04031
04035 inline XnBool IsJointAvailable(XnSkeletonJoint eJoint) const
04036 {
04037 return xnIsJointAvailable(GetHandle(), eJoint);
04038 }
04039
04043 inline XnBool IsProfileAvailable(XnSkeletonProfile eProfile) const
04044 {
04045 return xnIsProfileAvailable(GetHandle(), eProfile);
04046 }
04047
04051 inline XnStatus SetSkeletonProfile(XnSkeletonProfile eProfile)
04052 {
04053 return xnSetSkeletonProfile(GetHandle(), eProfile);
04054 }
04055
04059 inline XnStatus SetJointActive(XnSkeletonJoint eJoint, XnBool bState)
04060 {
04061 return xnSetJointActive(GetHandle(), eJoint, bState);
04062 }
04063
04067 XN_API_DEPRECATED("Use the version with one argument")
04068 inline XnBool IsJointActive(XnSkeletonJoint eJoint, XnBool ) const
04069 {
04070 return xnIsJointActive(GetHandle(), eJoint);
04071 }
04072
04076 inline XnBool IsJointActive(XnSkeletonJoint eJoint) const
04077 {
04078 return xnIsJointActive(GetHandle(), eJoint);
04079 }
04080
04084 inline XnStatus RegisterToJointConfigurationChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
04085 {
04086 return _RegisterToStateChange(xnRegisterToJointConfigurationChange, GetHandle(), handler, pCookie, hCallback);
04087 }
04088
04092 inline void UnregisterFromJointConfigurationChange(XnCallbackHandle hCallback)
04093 {
04094 _UnregisterFromStateChange(xnUnregisterFromJointConfigurationChange, GetHandle(), hCallback);
04095 }
04096
04100 inline XnStatus EnumerateActiveJoints(XnSkeletonJoint* pJoints, XnUInt16& nJoints) const
04101 {
04102 return xnEnumerateActiveJoints(GetHandle(), pJoints, &nJoints);
04103 }
04104
04108 inline XnStatus GetSkeletonJoint(XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointTransformation& Joint) const
04109 {
04110 return xnGetSkeletonJoint(GetHandle(), user, eJoint, &Joint);
04111 }
04112
04116 inline XnStatus GetSkeletonJointPosition(XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointPosition& Joint) const
04117 {
04118 return xnGetSkeletonJointPosition(GetHandle(), user, eJoint, &Joint);
04119 }
04120
04124 inline XnStatus GetSkeletonJointOrientation(XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointOrientation& Joint) const
04125 {
04126 return xnGetSkeletonJointOrientation(GetHandle(), user, eJoint, &Joint);
04127 }
04128
04132 inline XnBool IsTracking(XnUserID user) const
04133 {
04134 return xnIsSkeletonTracking(GetHandle(), user);
04135 }
04136
04140 inline XnBool IsCalibrated(XnUserID user) const
04141 {
04142 return xnIsSkeletonCalibrated(GetHandle(), user);
04143 }
04144
04148 inline XnBool IsCalibrating(XnUserID user) const
04149 {
04150 return xnIsSkeletonCalibrating(GetHandle(), user);
04151 }
04152
04156 inline XnStatus RequestCalibration(XnUserID user, XnBool bForce)
04157 {
04158 return xnRequestSkeletonCalibration(GetHandle(), user, bForce);
04159 }
04160
04164 inline XnStatus AbortCalibration(XnUserID user)
04165 {
04166 return xnAbortSkeletonCalibration(GetHandle(), user);
04167 }
04168
04172 inline XnStatus SaveCalibrationDataToFile(XnUserID user, const XnChar* strFileName)
04173 {
04174 return xnSaveSkeletonCalibrationDataToFile(GetHandle(), user, strFileName);
04175 }
04176
04180 inline XnStatus LoadCalibrationDataFromFile(XnUserID user, const XnChar* strFileName)
04181 {
04182 return xnLoadSkeletonCalibrationDataFromFile(GetHandle(), user, strFileName);
04183 }
04184
04188 inline XnStatus SaveCalibrationData(XnUserID user, XnUInt32 nSlot)
04189 {
04190 return xnSaveSkeletonCalibrationData(GetHandle(), user, nSlot);
04191 }
04192
04196 inline XnStatus LoadCalibrationData(XnUserID user, XnUInt32 nSlot)
04197 {
04198 return xnLoadSkeletonCalibrationData(GetHandle(), user, nSlot);
04199 }
04200
04204 inline XnStatus ClearCalibrationData(XnUInt32 nSlot)
04205 {
04206 return xnClearSkeletonCalibrationData(GetHandle(), nSlot);
04207 }
04208
04212 inline XnBool IsCalibrationData(XnUInt32 nSlot) const
04213 {
04214 return xnIsSkeletonCalibrationData(GetHandle(), nSlot);
04215 }
04216
04220 inline XnStatus StartTracking(XnUserID user)
04221 {
04222 return xnStartSkeletonTracking(GetHandle(), user);
04223 }
04224
04228 inline XnStatus StopTracking(XnUserID user)
04229 {
04230 return xnStopSkeletonTracking(GetHandle(), user);
04231 }
04232
04236 inline XnStatus Reset(XnUserID user)
04237 {
04238 return xnResetSkeleton(GetHandle(), user);
04239 }
04240
04244 inline XnBool NeedPoseForCalibration() const
04245 {
04246 return xnNeedPoseForSkeletonCalibration(GetHandle());
04247 }
04248
04252 inline XnStatus GetCalibrationPose(XnChar* strPose) const
04253 {
04254 return xnGetSkeletonCalibrationPose(GetHandle(), strPose);
04255 }
04256
04260 inline XnStatus SetSmoothing(XnFloat fSmoothingFactor)
04261 {
04262 return xnSetSkeletonSmoothing(GetHandle(), fSmoothingFactor);
04263 }
04264
04272 typedef void (XN_CALLBACK_TYPE* CalibrationStart)(SkeletonCapability& skeleton, XnUserID user, void* pCookie);
04281 typedef void (XN_CALLBACK_TYPE* CalibrationEnd)(SkeletonCapability& skeleton, XnUserID user, XnBool bSuccess, void* pCookie);
04282
04286 inline XnStatus XN_API_DEPRECATED("Please use RegisterToCalibrationStart/Complete") RegisterCalibrationCallbacks(CalibrationStart CalibrationStartCB, CalibrationEnd CalibrationEndCB, void* pCookie, XnCallbackHandle& hCallback)
04287 {
04288 XnStatus nRetVal = XN_STATUS_OK;
04289
04290 SkeletonCookie* pSkeletonCookie;
04291 XN_VALIDATE_ALLOC(pSkeletonCookie, SkeletonCookie);
04292 pSkeletonCookie->startHandler = CalibrationStartCB;
04293 pSkeletonCookie->endHandler = CalibrationEndCB;
04294 pSkeletonCookie->pUserCookie = pCookie;
04295
04296 #pragma warning (push)
04297 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
04298 nRetVal = xnRegisterCalibrationCallbacks(GetHandle(), CalibrationStartBundleCallback, CalibrationEndBundleCallback, pSkeletonCookie, &pSkeletonCookie->hCallback);
04299 #pragma warning (pop)
04300 if (nRetVal != XN_STATUS_OK)
04301 {
04302 xnOSFree(pSkeletonCookie);
04303 return (nRetVal);
04304 }
04305
04306 hCallback = pSkeletonCookie;
04307
04308 return (XN_STATUS_OK);
04309 }
04310
04314 inline void XN_API_DEPRECATED("Please use UnregisterFromCalibrationStart/Complete") UnregisterCalibrationCallbacks(XnCallbackHandle hCallback)
04315 {
04316 SkeletonCookie* pSkeletonCookie = (SkeletonCookie*)hCallback;
04317 #pragma warning (push)
04318 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
04319 xnUnregisterCalibrationCallbacks(GetHandle(), pSkeletonCookie->hCallback);
04320 #pragma warning (pop)
04321 xnOSFree(pSkeletonCookie);
04322 }
04323
04327 inline XnStatus RegisterToCalibrationStart(CalibrationStart handler, void* pCookie, XnCallbackHandle& hCallback)
04328 {
04329 XnStatus nRetVal = XN_STATUS_OK;
04330 CalibrationStartCookie* pCalibrationCookie;
04331 XN_VALIDATE_ALLOC(pCalibrationCookie, CalibrationStartCookie);
04332 pCalibrationCookie->handler = handler;
04333 pCalibrationCookie->pUserCookie = pCookie;
04334 nRetVal = xnRegisterToCalibrationStart(GetHandle(), CalibrationStartCallback, pCalibrationCookie, &pCalibrationCookie->hCallback);
04335 if (nRetVal != XN_STATUS_OK)
04336 {
04337 xnOSFree(pCalibrationCookie);
04338 return nRetVal;
04339 }
04340 hCallback = pCalibrationCookie;
04341 return XN_STATUS_OK;
04342 }
04346 inline XnStatus UnregisterFromCalibrationStart(XnCallbackHandle hCallback)
04347 {
04348 CalibrationStartCookie* pCalibrationCookie = (CalibrationStartCookie*)hCallback;
04349 xnUnregisterFromCalibrationStart(GetHandle(), pCalibrationCookie->hCallback);
04350 xnOSFree(pCalibrationCookie);
04351 }
04352
04361 typedef void (XN_CALLBACK_TYPE* CalibrationInProgress)(SkeletonCapability& skeleton, XnUserID user, XnCalibrationStatus calibrationError, void* pCookie);
04362
04366 inline XnStatus RegisterToCalibrationInProgress(CalibrationInProgress handler, void* pCookie, XnCallbackHandle& hCallback)
04367 {
04368 XnStatus nRetVal = XN_STATUS_OK;
04369
04370 CalibrationInProgressCookie* pSkeletonCookie;
04371 XN_VALIDATE_ALLOC(pSkeletonCookie, CalibrationInProgressCookie);
04372 pSkeletonCookie->handler = handler;
04373 pSkeletonCookie->pUserCookie = pCookie;
04374
04375 nRetVal = xnRegisterToCalibrationInProgress(GetHandle(), CalibrationInProgressCallback, pSkeletonCookie, &pSkeletonCookie->hCallback);
04376 if (nRetVal != XN_STATUS_OK)
04377 {
04378 xnOSFree(pSkeletonCookie);
04379 return (nRetVal);
04380 }
04381
04382 hCallback = pSkeletonCookie;
04383
04384 return (XN_STATUS_OK);
04385 }
04386
04390 inline void UnregisterFromCalibrationInProgress(XnCallbackHandle hCallback)
04391 {
04392 CalibrationInProgressCookie* pSkeletonCookie = (CalibrationInProgressCookie*)hCallback;
04393 xnUnregisterFromCalibrationInProgress(GetHandle(), pSkeletonCookie->hCallback);
04394 xnOSFree(pSkeletonCookie);
04395 }
04396
04405 typedef void (XN_CALLBACK_TYPE* CalibrationComplete)(SkeletonCapability& skeleton, XnUserID user, XnCalibrationStatus calibrationError, void* pCookie);
04409 inline XnStatus RegisterToCalibrationComplete(CalibrationComplete handler, void* pCookie, XnCallbackHandle& hCallback)
04410 {
04411 XnStatus nRetVal = XN_STATUS_OK;
04412
04413 CalibrationCompleteCookie* pSkeletonCookie;
04414 XN_VALIDATE_ALLOC(pSkeletonCookie, CalibrationCompleteCookie);
04415 pSkeletonCookie->handler = handler;
04416 pSkeletonCookie->pUserCookie = pCookie;
04417
04418 nRetVal = xnRegisterToCalibrationComplete(GetHandle(), CalibrationCompleteCallback, pSkeletonCookie, &pSkeletonCookie->hCallback);
04419 if (nRetVal != XN_STATUS_OK)
04420 {
04421 xnOSFree(pSkeletonCookie);
04422 return (nRetVal);
04423 }
04424
04425 hCallback = pSkeletonCookie;
04426
04427 return (XN_STATUS_OK);
04428 }
04429
04433 inline void UnregisterFromCalibrationComplete(XnCallbackHandle hCallback)
04434 {
04435 CalibrationCompleteCookie* pSkeletonCookie = (CalibrationCompleteCookie*)hCallback;
04436 xnUnregisterFromCalibrationComplete(GetHandle(), pSkeletonCookie->hCallback);
04437 xnOSFree(pSkeletonCookie);
04438 }
04439 private:
04440 typedef struct SkeletonCookie
04441 {
04442 CalibrationStart startHandler;
04443 CalibrationEnd endHandler;
04444 void* pUserCookie;
04445 XnCallbackHandle hCallback;
04446 } SkeletonCookie;
04447
04448 static void XN_CALLBACK_TYPE CalibrationStartBundleCallback(XnNodeHandle hNode, XnUserID user, void* pCookie)
04449 {
04450 SkeletonCookie* pSkeletonCookie = (SkeletonCookie*)pCookie;
04451 SkeletonCapability cap(hNode);
04452 if (pSkeletonCookie->startHandler != NULL)
04453 {
04454 pSkeletonCookie->startHandler(cap, user, pSkeletonCookie->pUserCookie);
04455 }
04456 }
04457
04458 static void XN_CALLBACK_TYPE CalibrationEndBundleCallback(XnNodeHandle hNode, XnUserID user, XnBool bSuccess, void* pCookie)
04459 {
04460 SkeletonCookie* pSkeletonCookie = (SkeletonCookie*)pCookie;
04461 SkeletonCapability cap(hNode);
04462 if (pSkeletonCookie->endHandler != NULL)
04463 {
04464 pSkeletonCookie->endHandler(cap, user, bSuccess, pSkeletonCookie->pUserCookie);
04465 }
04466 }
04467 typedef struct CalibrationStartCookie
04468 {
04469 CalibrationStart handler;
04470 void* pUserCookie;
04471 XnCallbackHandle hCallback;
04472 } CalibrationStartCookie;
04473
04474 static void XN_CALLBACK_TYPE CalibrationStartCallback(XnNodeHandle hNode, XnUserID user, void* pCookie)
04475 {
04476 CalibrationStartCookie* pCalibrationCookie = (CalibrationStartCookie*)pCookie;
04477 SkeletonCapability cap(hNode);
04478 if (pCalibrationCookie->handler != NULL)
04479 {
04480 pCalibrationCookie->handler(cap, user, pCalibrationCookie->pUserCookie);
04481 }
04482 }
04483 typedef struct CalibrationInProgressCookie
04484 {
04485 CalibrationInProgress handler;
04486 void* pUserCookie;
04487 XnCallbackHandle hCallback;
04488 } CalibrationInProgressCookie;
04489
04490 static void XN_CALLBACK_TYPE CalibrationInProgressCallback(XnNodeHandle hNode, XnUserID user, XnCalibrationStatus calibrationError, void* pCookie)
04491 {
04492 CalibrationInProgressCookie* pSkeletonCookie = (CalibrationInProgressCookie*)pCookie;
04493 SkeletonCapability cap(hNode);
04494 if (pSkeletonCookie->handler != NULL)
04495 {
04496 pSkeletonCookie->handler(cap, user, calibrationError, pSkeletonCookie->pUserCookie);
04497 }
04498 }
04499
04500 typedef struct CalibrationCompleteCookie
04501 {
04502 CalibrationComplete handler;
04503 void* pUserCookie;
04504 XnCallbackHandle hCallback;
04505 } CalibrationCompleteCookie;
04506
04507 static void XN_CALLBACK_TYPE CalibrationCompleteCallback(XnNodeHandle hNode, XnUserID user, XnCalibrationStatus calibrationError, void* pCookie)
04508 {
04509 CalibrationCompleteCookie* pSkeletonCookie = (CalibrationCompleteCookie*)pCookie;
04510 SkeletonCapability cap(hNode);
04511 if (pSkeletonCookie->handler != NULL)
04512 {
04513 pSkeletonCookie->handler(cap, user, calibrationError, pSkeletonCookie->pUserCookie);
04514 }
04515 }
04516 };
04517
04522 class PoseDetectionCapability : public Capability
04523 {
04524 public:
04530 inline PoseDetectionCapability(XnNodeHandle hNode) : Capability(hNode) {}
04531 PoseDetectionCapability(const NodeWrapper& node) : Capability(node) {}
04532
04541 typedef void (XN_CALLBACK_TYPE* PoseDetection)(PoseDetectionCapability& pose, const XnChar* strPose, XnUserID user, void* pCookie);
04542
04546 inline XnUInt32 GetNumberOfPoses() const
04547 {
04548 return xnGetNumberOfPoses(GetHandle());
04549 }
04550
04554 inline XnStatus GetAvailablePoses(XnChar** pstrPoses, XnUInt32& nPoses) const
04555 {
04556 return xnGetAvailablePoses(GetHandle(), pstrPoses, &nPoses);
04557 }
04561 inline XnStatus GetAllAvailablePoses(XnChar** pstrPoses, XnUInt32 nNameLength, XnUInt32& nPoses) const
04562 {
04563 return xnGetAllAvailablePoses(GetHandle(), pstrPoses, nNameLength, &nPoses);
04564 }
04565
04569 inline XnStatus StartPoseDetection(const XnChar* strPose, XnUserID user)
04570 {
04571 return xnStartPoseDetection(GetHandle(), strPose, user);
04572 }
04573
04577 inline XnStatus StopPoseDetection(XnUserID user)
04578 {
04579 return xnStopPoseDetection(GetHandle(), user);
04580 }
04581
04585 inline XnStatus XN_API_DEPRECATED("Please use RegisterToPoseDetected/RegisterToOutOfPose instead") RegisterToPoseCallbacks(PoseDetection PoseStartCB, PoseDetection PoseEndCB, void* pCookie, XnCallbackHandle& hCallback)
04586 {
04587 XnStatus nRetVal = XN_STATUS_OK;
04588
04589 PoseCookie* pPoseCookie;
04590 XN_VALIDATE_ALLOC(pPoseCookie, PoseCookie);
04591 pPoseCookie->startHandler = PoseStartCB;
04592 pPoseCookie->endHandler = PoseEndCB;
04593 pPoseCookie->pPoseCookie = pCookie;
04594
04595 #pragma warning (push)
04596 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
04597 nRetVal = xnRegisterToPoseCallbacks(GetHandle(), PoseDetectionStartBundleCallback, PoseDetectionStartEndBundleCallback, pPoseCookie, &pPoseCookie->hCallback);
04598 #pragma warning (pop)
04599 if (nRetVal != XN_STATUS_OK)
04600 {
04601 xnOSFree(pPoseCookie);
04602 return (nRetVal);
04603 }
04604
04605 hCallback = pPoseCookie;
04606
04607 return (XN_STATUS_OK);
04608 }
04609
04613 inline void XN_API_DEPRECATED("Please use UnregisterFromPoseDetected/UnregisterFromOutOfPose instead") UnregisterFromPoseCallbacks(XnCallbackHandle hCallback)
04614 {
04615 PoseCookie* pPoseCookie = (PoseCookie*)hCallback;
04616 #pragma warning (push)
04617 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
04618 xnUnregisterFromPoseCallbacks(GetHandle(), pPoseCookie->hCallback);
04619 #pragma warning (pop)
04620 xnOSFree(pPoseCookie);
04621 }
04622
04626 inline XnStatus RegisterToPoseDetected(PoseDetection handler, void* pCookie, XnCallbackHandle& hCallback)
04627 {
04628 XnStatus nRetVal = XN_STATUS_OK;
04629 PoseDetectionCookie* pPoseCookie;
04630 XN_VALIDATE_ALLOC(pPoseCookie, PoseDetectionCookie);
04631 pPoseCookie->handler = handler;
04632 pPoseCookie->pPoseCookie = pCookie;
04633
04634 nRetVal = xnRegisterToPoseDetected(GetHandle(), PoseDetectionCallback, pPoseCookie, &pPoseCookie->hCallback);
04635 if (nRetVal != XN_STATUS_OK)
04636 {
04637 xnOSFree(pPoseCookie);
04638 return nRetVal;
04639 }
04640 hCallback = pPoseCookie;
04641 return XN_STATUS_OK;
04642 }
04646 inline XnStatus RegisterToOutOfPose(PoseDetection handler, void* pCookie, XnCallbackHandle& hCallback)
04647 {
04648 XnStatus nRetVal = XN_STATUS_OK;
04649 PoseDetectionCookie* pPoseCookie;
04650 XN_VALIDATE_ALLOC(pPoseCookie, PoseDetectionCookie);
04651 pPoseCookie->handler = handler;
04652 pPoseCookie->pPoseCookie = pCookie;
04653
04654 nRetVal = xnRegisterToOutOfPose(GetHandle(), PoseDetectionCallback, pPoseCookie, &pPoseCookie->hCallback);
04655 if (nRetVal != XN_STATUS_OK)
04656 {
04657 xnOSFree(pPoseCookie);
04658 return nRetVal;
04659 }
04660 hCallback = pPoseCookie;
04661 return XN_STATUS_OK;
04662 }
04666 inline void UnregisterFromPoseDetected(XnCallbackHandle hCallback)
04667 {
04668 PoseDetectionCookie* pPoseCookie = (PoseDetectionCookie*)hCallback;
04669 xnUnregisterFromPoseDetected(GetHandle(), pPoseCookie->hCallback);
04670 xnOSFree(pPoseCookie);
04671 }
04675 inline void UnregisterFromOutOfPose(XnCallbackHandle hCallback)
04676 {
04677 PoseDetectionCookie* pPoseCookie = (PoseDetectionCookie*)hCallback;
04678 xnUnregisterFromOutOfPose(GetHandle(), pPoseCookie->hCallback);
04679 xnOSFree(pPoseCookie);
04680 }
04681
04691 typedef void (XN_CALLBACK_TYPE* PoseInProgress)(PoseDetectionCapability& pose, const XnChar* strPose, XnUserID user, XnPoseDetectionStatus poseError, void* pCookie);
04695 inline XnStatus RegisterToPoseInProgress(PoseInProgress handler, void* pCookie, XnCallbackHandle& hCallback)
04696 {
04697 XnStatus nRetVal = XN_STATUS_OK;
04698
04699 PoseInProgressCookie* pPoseCookie;
04700 XN_VALIDATE_ALLOC(pPoseCookie, PoseInProgressCookie);
04701 pPoseCookie->handler = handler;
04702 pPoseCookie->pPoseCookie = pCookie;
04703
04704 nRetVal = xnRegisterToPoseDetectionInProgress(GetHandle(), PoseDetectionInProgressCallback, pPoseCookie, &pPoseCookie->hCallback);
04705 if (nRetVal != XN_STATUS_OK)
04706 {
04707 xnOSFree(pPoseCookie);
04708 return (nRetVal);
04709 }
04710
04711 hCallback = pPoseCookie;
04712
04713 return (XN_STATUS_OK);
04714 }
04715
04719 inline void UnregisterFromPoseInProgress(XnCallbackHandle hCallback)
04720 {
04721 PoseInProgressCookie* pPoseCookie = (PoseInProgressCookie*)hCallback;
04722 xnUnregisterFromPoseDetectionInProgress(GetHandle(), pPoseCookie->hCallback);
04723 xnOSFree(pPoseCookie);
04724 }
04725
04726 private:
04727 typedef struct PoseCookie
04728 {
04729 PoseDetection startHandler;
04730 PoseDetection endHandler;
04731 void* pPoseCookie;
04732 XnCallbackHandle hCallback;
04733 } PoseCookie;
04734
04735 static void XN_CALLBACK_TYPE PoseDetectionStartBundleCallback(XnNodeHandle hNode, const XnChar* strPose, XnUserID user, void* pCookie)
04736 {
04737 PoseCookie* pPoseCookie = (PoseCookie*)pCookie;
04738 PoseDetectionCapability cap(hNode);
04739 if (pPoseCookie->startHandler != NULL)
04740 {
04741 pPoseCookie->startHandler(cap, strPose, user, pPoseCookie->pPoseCookie);
04742 }
04743 }
04744
04745 static void XN_CALLBACK_TYPE PoseDetectionStartEndBundleCallback(XnNodeHandle hNode, const XnChar* strPose, XnUserID user, void* pCookie)
04746 {
04747 PoseCookie* pPoseCookie = (PoseCookie*)pCookie;
04748 PoseDetectionCapability cap(hNode);
04749 if (pPoseCookie->endHandler != NULL)
04750 {
04751 pPoseCookie->endHandler(cap, strPose, user, pPoseCookie->pPoseCookie);
04752 }
04753 }
04754 typedef struct PoseDetectionCookie
04755 {
04756 PoseDetection handler;
04757 void* pPoseCookie;
04758 XnCallbackHandle hCallback;
04759 } PoseDetectionCookie;
04760 static void XN_CALLBACK_TYPE PoseDetectionCallback(XnNodeHandle hNode, const XnChar* strPose, XnUserID user, void* pCookie)
04761 {
04762 PoseDetectionCookie* pPoseDetectionCookie = (PoseDetectionCookie*)pCookie;
04763 PoseDetectionCapability cap(hNode);
04764 if (pPoseDetectionCookie->handler != NULL)
04765 {
04766 pPoseDetectionCookie->handler(cap, strPose, user, pPoseDetectionCookie->pPoseCookie);
04767 }
04768 }
04769
04770 typedef struct PoseInProgressCookie
04771 {
04772 PoseInProgress handler;
04773 void* pPoseCookie;
04774 XnCallbackHandle hCallback;
04775 } PoseInProgressCookie;
04776
04777 static void XN_CALLBACK_TYPE PoseDetectionInProgressCallback(XnNodeHandle hNode, const XnChar* strPose, XnUserID user, XnPoseDetectionStatus poseErrors, void* pCookie)
04778 {
04779 PoseInProgressCookie* pPoseCookie = (PoseInProgressCookie*)pCookie;
04780 PoseDetectionCapability cap(hNode);
04781 if (pPoseCookie->handler != NULL)
04782 {
04783 pPoseCookie->handler(cap, strPose, user, poseErrors, pPoseCookie->pPoseCookie);
04784 }
04785 }
04786 };
04787
04792 class UserGenerator : public Generator
04793 {
04794 public:
04800 inline UserGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {}
04801 inline UserGenerator(const NodeWrapper& other) : Generator(other) {}
04802
04806 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL);
04807
04808 typedef void (XN_CALLBACK_TYPE* UserHandler)(UserGenerator& generator, XnUserID user, void* pCookie);
04809
04813 inline XnUInt16 GetNumberOfUsers() const
04814 {
04815 return xnGetNumberOfUsers(GetHandle());
04816 }
04817
04821 inline XnStatus GetUsers(XnUserID aUsers[], XnUInt16& nUsers) const
04822 {
04823 return xnGetUsers(GetHandle(), aUsers, &nUsers);
04824 }
04825
04829 inline XnStatus GetCoM(XnUserID user, XnPoint3D& com) const
04830 {
04831 return xnGetUserCoM(GetHandle(), user, &com);
04832 }
04833
04837 inline XnStatus GetUserPixels(XnUserID user, SceneMetaData& smd) const
04838 {
04839 return xnGetUserPixels(GetHandle(), user, smd.GetUnderlying());
04840 }
04841
04845 inline XnStatus RegisterUserCallbacks(UserHandler NewUserCB, UserHandler LostUserCB, void* pCookie, XnCallbackHandle& hCallback)
04846 {
04847 XnStatus nRetVal = XN_STATUS_OK;
04848
04849 UserCookie* pUserCookie;
04850 XN_VALIDATE_ALLOC(pUserCookie, UserCookie);
04851 pUserCookie->newHandler = NewUserCB;
04852 pUserCookie->lostHandler = LostUserCB;
04853 pUserCookie->pUserCookie = pCookie;
04854
04855 nRetVal = xnRegisterUserCallbacks(GetHandle(), NewUserCallback, LostUserCallback, pUserCookie, &pUserCookie->hCallback);
04856 if (nRetVal != XN_STATUS_OK)
04857 {
04858 xnOSFree(pUserCookie);
04859 return (nRetVal);
04860 }
04861
04862 hCallback = pUserCookie;
04863
04864 return (XN_STATUS_OK);
04865 }
04866
04870 inline void UnregisterUserCallbacks(XnCallbackHandle hCallback)
04871 {
04872 UserCookie* pUserCookie = (UserCookie*)hCallback;
04873 xnUnregisterUserCallbacks(GetHandle(), pUserCookie->hCallback);
04874 xnOSFree(pUserCookie);
04875 }
04876
04882 inline const SkeletonCapability GetSkeletonCap() const
04883 {
04884 return SkeletonCapability(GetHandle());
04885 }
04886
04892 inline SkeletonCapability GetSkeletonCap()
04893 {
04894 return SkeletonCapability(GetHandle());
04895 }
04896
04902 inline const PoseDetectionCapability GetPoseDetectionCap() const
04903 {
04904 return PoseDetectionCapability(GetHandle());
04905 }
04906
04912 inline PoseDetectionCapability GetPoseDetectionCap()
04913 {
04914 return PoseDetectionCapability(GetHandle());
04915 }
04916
04920 inline XnStatus RegisterToUserExit(UserHandler handler, void* pCookie, XnCallbackHandle& hCallback)
04921 {
04922 XnStatus nRetVal = XN_STATUS_OK;
04923
04924 UserSingleCookie* pUserCookie;
04925 XN_VALIDATE_ALLOC(pUserCookie, UserSingleCookie);
04926 pUserCookie->handler = handler;
04927 pUserCookie->pUserCookie = pCookie;
04928
04929 nRetVal = xnRegisterToUserExit(GetHandle(), UserSingleCallback, pUserCookie, &pUserCookie->hCallback);
04930 if (nRetVal != XN_STATUS_OK)
04931 {
04932 xnOSFree(pUserCookie);
04933 return (nRetVal);
04934 }
04935
04936 hCallback = pUserCookie;
04937
04938 return (XN_STATUS_OK);
04939 }
04940
04944 inline void UnregisterFromUserExit(XnCallbackHandle hCallback)
04945 {
04946 UserSingleCookie* pUserCookie = (UserSingleCookie*)hCallback;
04947 xnUnregisterFromUserExit(GetHandle(), pUserCookie->hCallback);
04948 xnOSFree(pUserCookie);
04949 }
04950
04954 inline XnStatus RegisterToUserReEnter(UserHandler handler, void* pCookie, XnCallbackHandle& hCallback)
04955 {
04956 XnStatus nRetVal = XN_STATUS_OK;
04957
04958 UserSingleCookie* pUserCookie;
04959 XN_VALIDATE_ALLOC(pUserCookie, UserSingleCookie);
04960 pUserCookie->handler = handler;
04961 pUserCookie->pUserCookie = pCookie;
04962
04963 nRetVal = xnRegisterToUserReEnter(GetHandle(), UserSingleCallback, pUserCookie, &pUserCookie->hCallback);
04964 if (nRetVal != XN_STATUS_OK)
04965 {
04966 xnOSFree(pUserCookie);
04967 return (nRetVal);
04968 }
04969
04970 hCallback = pUserCookie;
04971
04972 return (XN_STATUS_OK);
04973 }
04974
04978 inline void UnregisterFromUserReEnter(XnCallbackHandle hCallback)
04979 {
04980 UserSingleCookie* pUserCookie = (UserSingleCookie*)hCallback;
04981 xnUnregisterFromUserReEnter(GetHandle(), pUserCookie->hCallback);
04982 xnOSFree(pUserCookie);
04983 }
04984
04985 private:
04986 typedef struct UserCookie
04987 {
04988 UserHandler newHandler;
04989 UserHandler lostHandler;
04990 void* pUserCookie;
04991 XnCallbackHandle hCallback;
04992 } UserCookie;
04993
04994 static void XN_CALLBACK_TYPE NewUserCallback(XnNodeHandle hNode, XnUserID user, void* pCookie)
04995 {
04996 UserCookie* pUserCookie = (UserCookie*)pCookie;
04997 UserGenerator gen(hNode);
04998 if (pUserCookie->newHandler != NULL)
04999 {
05000 pUserCookie->newHandler(gen, user, pUserCookie->pUserCookie);
05001 }
05002 }
05003
05004 static void XN_CALLBACK_TYPE LostUserCallback(XnNodeHandle hNode, XnUserID user, void* pCookie)
05005 {
05006 UserCookie* pUserCookie = (UserCookie*)pCookie;
05007 UserGenerator gen(hNode);
05008 if (pUserCookie->lostHandler != NULL)
05009 {
05010 pUserCookie->lostHandler(gen, user, pUserCookie->pUserCookie);
05011 }
05012 }
05013
05014 typedef struct UserSingleCookie
05015 {
05016 UserHandler handler;
05017 void* pUserCookie;
05018 XnCallbackHandle hCallback;
05019 } UserSingleCookie;
05020
05021 static void XN_CALLBACK_TYPE UserSingleCallback(XnNodeHandle hNode, XnUserID user, void* pCookie)
05022 {
05023 UserSingleCookie* pUserCookie = (UserSingleCookie*)pCookie;
05024 UserGenerator gen(hNode);
05025 if (pUserCookie->handler != NULL)
05026 {
05027 pUserCookie->handler(gen, user, pUserCookie->pUserCookie);
05028 }
05029 }
05030 };
05031
05036 class AudioGenerator : public Generator
05037 {
05038 public:
05044 inline AudioGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {}
05045 inline AudioGenerator(const NodeWrapper& other) : Generator(other) {}
05046
05050 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL);
05051
05055 inline void GetMetaData(AudioMetaData& metaData) const
05056 {
05057 xnGetAudioMetaData(GetHandle(), metaData.GetUnderlying());
05058 }
05059
05063 inline const XnUChar* GetAudioBuffer() const
05064 {
05065 return xnGetAudioBuffer(GetHandle());
05066 }
05067
05071 inline XnUInt32 GetSupportedWaveOutputModesCount() const
05072 {
05073 return xnGetSupportedWaveOutputModesCount(GetHandle());
05074 }
05075
05079 inline XnStatus GetSupportedWaveOutputModes(XnWaveOutputMode* aSupportedModes, XnUInt32& nCount) const
05080 {
05081 return xnGetSupportedWaveOutputModes(GetHandle(), aSupportedModes, &nCount);
05082 }
05083
05087 inline XnStatus SetWaveOutputMode(const XnWaveOutputMode& OutputMode)
05088 {
05089 return xnSetWaveOutputMode(GetHandle(), &OutputMode);
05090 }
05091
05095 inline XnStatus GetWaveOutputMode(XnWaveOutputMode& OutputMode) const
05096 {
05097 return xnGetWaveOutputMode(GetHandle(), &OutputMode);
05098 }
05099
05103 inline XnStatus RegisterToWaveOutputModeChanges(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
05104 {
05105 return _RegisterToStateChange(xnRegisterToWaveOutputModeChanges, GetHandle(), handler, pCookie, hCallback);
05106 }
05107
05111 inline void UnregisterFromWaveOutputModeChanges(XnCallbackHandle hCallback)
05112 {
05113 _UnregisterFromStateChange(xnUnregisterFromWaveOutputModeChanges, GetHandle(), hCallback);
05114 }
05115 };
05116
05121 class MockAudioGenerator : public AudioGenerator
05122 {
05123 public:
05129 inline MockAudioGenerator(XnNodeHandle hNode = NULL) : AudioGenerator(hNode) {}
05130 inline MockAudioGenerator(const NodeWrapper& other) : AudioGenerator(other) {}
05131
05138 XnStatus Create(Context& context, const XnChar* strName = NULL);
05139
05146 XnStatus CreateBasedOn(AudioGenerator& other, const XnChar* strName = NULL);
05147
05151 inline XnStatus SetData(XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize, const XnUInt8* pAudioBuffer)
05152 {
05153 return xnMockAudioSetData(GetHandle(), nFrameID, nTimestamp, nDataSize, pAudioBuffer);
05154 }
05155
05163 inline XnStatus SetData(const AudioMetaData& audioMD, XnUInt32 nFrameID, XnUInt64 nTimestamp)
05164 {
05165 return SetData(nFrameID, nTimestamp, audioMD.DataSize(), audioMD.Data());
05166 }
05167
05173 inline XnStatus SetData(const AudioMetaData& audioMD)
05174 {
05175 return SetData(audioMD, audioMD.FrameID(), audioMD.Timestamp());
05176 }
05177 };
05178
05179 class MockRawGenerator : public Generator
05180 {
05181 public:
05182 MockRawGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {}
05183 MockRawGenerator(const NodeWrapper& other) : Generator(other) {}
05184
05185 inline XnStatus Create(Context& context, const XnChar* strName = NULL);
05186
05187 inline XnStatus SetData(XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize, const void* pData)
05188 {
05189 return xnMockRawSetData(GetHandle(), nFrameID, nTimestamp, nDataSize, pData);
05190 }
05191
05192 };
05193
05198 class Codec : public ProductionNode
05199 {
05200 public:
05206 inline Codec(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {}
05207 inline Codec(const NodeWrapper& other) : ProductionNode(other) {}
05208
05212 inline XnStatus Create(Context& context, XnCodecID codecID, ProductionNode& initializerNode);
05213
05217 inline XnCodecID GetCodecID() const
05218 {
05219 return xnGetCodecID(GetHandle());
05220 }
05221
05225 inline XnStatus EncodeData(const void* pSrc, XnUInt32 nSrcSize, void* pDst, XnUInt32 nDstSize, XnUInt* pnBytesWritten) const
05226 {
05227 return xnEncodeData(GetHandle(), pSrc, nSrcSize, pDst, nDstSize, pnBytesWritten);
05228 }
05229
05233 inline XnStatus DecodeData(const void* pSrc, XnUInt32 nSrcSize, void* pDst, XnUInt32 nDstSize, XnUInt* pnBytesWritten) const
05234 {
05235 return xnDecodeData(GetHandle(), pSrc, nSrcSize, pDst, nDstSize, pnBytesWritten);
05236 }
05237 };
05238
05243 class ScriptNode : public ProductionNode
05244 {
05245 public:
05251 inline ScriptNode(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {}
05252 inline ScriptNode(const NodeWrapper& other) : ProductionNode(other) {}
05253
05254 inline const XnChar* GetSupportedFormat()
05255 {
05256 return xnScriptNodeGetSupportedFormat(GetHandle());
05257 }
05258
05259 inline XnStatus LoadScriptFromFile(const XnChar* strFileName)
05260 {
05261 return xnLoadScriptFromFile(GetHandle(), strFileName);
05262 }
05263
05264 inline XnStatus LoadScriptFromString(const XnChar* strScript)
05265 {
05266 return xnLoadScriptFromString(GetHandle(), strScript);
05267 }
05268
05269 inline XnStatus Run(EnumerationErrors* pErrors);
05270 };
05271
05272
05273
05274
05279 class EnumerationErrors
05280 {
05281 public:
05283 inline EnumerationErrors() : m_bAllocated(TRUE), m_pErrors(NULL) { xnEnumerationErrorsAllocate(&m_pErrors); }
05284
05291 inline EnumerationErrors(XnEnumerationErrors* pErrors, XnBool bOwn = FALSE) : m_bAllocated(bOwn), m_pErrors(pErrors) {}
05292
05294 ~EnumerationErrors() { Free(); }
05295
05297 class Iterator
05298 {
05299 public:
05300 friend class EnumerationErrors;
05301
05307 XnBool operator==(const Iterator& other) const
05308 {
05309 return m_it == other.m_it;
05310 }
05311
05317 XnBool operator!=(const Iterator& other) const
05318 {
05319 return m_it != other.m_it;
05320 }
05321
05326 inline Iterator& operator++()
05327 {
05328 m_it = xnEnumerationErrorsGetNext(m_it);
05329 return *this;
05330 }
05331
05336 inline Iterator operator++(int)
05337 {
05338 return Iterator(xnEnumerationErrorsGetNext(m_it));
05339 }
05340
05342 inline const XnProductionNodeDescription& Description() { return *xnEnumerationErrorsGetCurrentDescription(m_it); }
05344 inline XnStatus Error() { return xnEnumerationErrorsGetCurrentError(m_it); }
05345
05346 private:
05347 inline Iterator(XnEnumerationErrorsIterator it) : m_it(it) {}
05348
05349 XnEnumerationErrorsIterator m_it;
05350 };
05351
05353 inline Iterator Begin() const { return Iterator(xnEnumerationErrorsGetFirst(m_pErrors)); }
05355 inline Iterator End() const { return Iterator(NULL); }
05356
05360 inline XnStatus ToString(XnChar* csBuffer, XnUInt32 nSize)
05361 {
05362 return xnEnumerationErrorsToString(m_pErrors, csBuffer, nSize);
05363 }
05364
05368 inline void Free()
05369 {
05370 if (m_bAllocated)
05371 {
05372 xnEnumerationErrorsFree(m_pErrors);
05373 m_pErrors = NULL;
05374 m_bAllocated = FALSE;
05375 }
05376 }
05377
05379 inline XnEnumerationErrors* GetUnderlying() { return m_pErrors; }
05380
05381 private:
05382 XnEnumerationErrors* m_pErrors;
05383 XnBool m_bAllocated;
05384 };
05385
05386
05387
05388
05389
05394 class Context
05395 {
05396 public:
05398 inline Context() : m_pContext(NULL), m_bUsingDeprecatedAPI(FALSE), m_bAllocated(FALSE), m_hShuttingDownCallback(NULL) {}
05399
05405 inline Context(XnContext* pContext) : m_pContext(NULL), m_bUsingDeprecatedAPI(FALSE), m_bAllocated(FALSE), m_hShuttingDownCallback(NULL)
05406 {
05407 SetHandle(pContext);
05408 }
05409
05416 inline Context(const Context& other) : m_pContext(NULL), m_bUsingDeprecatedAPI(FALSE), m_bAllocated(FALSE), m_hShuttingDownCallback(NULL)
05417 {
05418 SetHandle(other.m_pContext);
05419 }
05420
05422 ~Context()
05423 {
05424 SetHandle(NULL);
05425 }
05426
05427 inline Context& operator=(const Context& other)
05428 {
05429 SetHandle(other.m_pContext);
05430 return *this;
05431 }
05432
05434 inline XnContext* GetUnderlyingObject() const { return m_pContext; }
05435
05439 inline XnStatus Init()
05440 {
05441 XnContext* pContext = NULL;
05442 XnStatus nRetVal = xnInit(&pContext);
05443 XN_IS_STATUS_OK(nRetVal);
05444
05445 TakeOwnership(pContext);
05446 m_bAllocated = TRUE;
05447
05448 return (XN_STATUS_OK);
05449 }
05450
05454 inline XnStatus XN_API_DEPRECATED("Use other overload!") RunXmlScript(const XnChar* strScript, EnumerationErrors* pErrors = NULL)
05455 {
05456 m_bUsingDeprecatedAPI = TRUE;
05457 #pragma warning (push)
05458 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
05459 return xnContextRunXmlScript(m_pContext, strScript, pErrors == NULL ? NULL : pErrors->GetUnderlying());
05460 #pragma warning (pop)
05461 }
05462
05466 inline XnStatus RunXmlScript(const XnChar* strScript, ScriptNode& scriptNode, EnumerationErrors* pErrors = NULL)
05467 {
05468 XnStatus nRetVal = XN_STATUS_OK;
05469
05470 XnNodeHandle hScriptNode;
05471 nRetVal = xnContextRunXmlScriptEx(m_pContext, strScript, pErrors == NULL ? NULL : pErrors->GetUnderlying(), &hScriptNode);
05472 XN_IS_STATUS_OK(nRetVal);
05473
05474 scriptNode.TakeOwnership(hScriptNode);
05475
05476 return (XN_STATUS_OK);
05477 }
05478
05482 inline XnStatus XN_API_DEPRECATED("Use other overload!") RunXmlScriptFromFile(const XnChar* strFileName, EnumerationErrors* pErrors = NULL)
05483 {
05484 m_bUsingDeprecatedAPI = TRUE;
05485 #pragma warning (push)
05486 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
05487 return xnContextRunXmlScriptFromFile(m_pContext, strFileName, pErrors == NULL ? NULL : pErrors->GetUnderlying());
05488 #pragma warning (pop)
05489 }
05490
05494 inline XnStatus RunXmlScriptFromFile(const XnChar* strFileName, ScriptNode& scriptNode, EnumerationErrors* pErrors = NULL)
05495 {
05496 XnStatus nRetVal = XN_STATUS_OK;
05497
05498 XnNodeHandle hScriptNode;
05499 nRetVal = xnContextRunXmlScriptFromFileEx(m_pContext, strFileName, pErrors == NULL ? NULL : pErrors->GetUnderlying(), &hScriptNode);
05500 XN_IS_STATUS_OK(nRetVal);
05501
05502 scriptNode.TakeOwnership(hScriptNode);
05503
05504 return (XN_STATUS_OK);
05505 }
05506
05510 inline XnStatus XN_API_DEPRECATED("Use other overload!") InitFromXmlFile(const XnChar* strFileName, EnumerationErrors* pErrors = NULL)
05511 {
05512 XnContext* pContext = NULL;
05513 m_bUsingDeprecatedAPI = TRUE;
05514
05515 #pragma warning (push)
05516 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
05517 XnStatus nRetVal = xnInitFromXmlFile(strFileName, &pContext, pErrors == NULL ? NULL : pErrors->GetUnderlying());
05518 #pragma warning (pop)
05519 XN_IS_STATUS_OK(nRetVal);
05520
05521 TakeOwnership(pContext);
05522 m_bAllocated = TRUE;
05523
05524 return (XN_STATUS_OK);
05525 }
05526
05530 inline XnStatus InitFromXmlFile(const XnChar* strFileName, ScriptNode& scriptNode, EnumerationErrors* pErrors = NULL)
05531 {
05532 XnContext* pContext = NULL;
05533
05534 XnNodeHandle hScriptNode;
05535 XnStatus nRetVal = xnInitFromXmlFileEx(strFileName, &pContext, pErrors == NULL ? NULL : pErrors->GetUnderlying(), &hScriptNode);
05536 XN_IS_STATUS_OK(nRetVal);
05537
05538 scriptNode.TakeOwnership(hScriptNode);
05539 TakeOwnership(pContext);
05540 m_bAllocated = TRUE;
05541
05542 return (XN_STATUS_OK);
05543 }
05544
05548 inline XnStatus XN_API_DEPRECATED("Use other overload!") OpenFileRecording(const XnChar* strFileName)
05549 {
05550 m_bUsingDeprecatedAPI = TRUE;
05551 #pragma warning (push)
05552 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
05553 return xnContextOpenFileRecording(m_pContext, strFileName);
05554 #pragma warning (pop)
05555 }
05556
05560 inline XnStatus OpenFileRecording(const XnChar* strFileName, ProductionNode& playerNode)
05561 {
05562 XnStatus nRetVal = XN_STATUS_OK;
05563
05564 XnNodeHandle hPlayer;
05565 nRetVal = xnContextOpenFileRecordingEx(m_pContext, strFileName, &hPlayer);
05566 XN_IS_STATUS_OK(nRetVal);
05567
05568 playerNode.TakeOwnership(hPlayer);
05569
05570 return (XN_STATUS_OK);
05571 }
05572
05576 inline XnStatus CreateMockNode(XnProductionNodeType type, const XnChar* strName, ProductionNode& mockNode)
05577 {
05578 XnStatus nRetVal = XN_STATUS_OK;
05579
05580 XnNodeHandle hMockNode;
05581 nRetVal = xnCreateMockNode(m_pContext, type, strName, &hMockNode);
05582 XN_IS_STATUS_OK(nRetVal);
05583
05584 mockNode.TakeOwnership(hMockNode);
05585
05586 return (XN_STATUS_OK);
05587 }
05588
05592 inline XnStatus CreateMockNodeBasedOn(ProductionNode& originalNode, const XnChar* strName, ProductionNode& mockNode)
05593 {
05594 XnStatus nRetVal = XN_STATUS_OK;
05595
05596 XnNodeHandle hMockNode;
05597 nRetVal = xnCreateMockNodeBasedOn(m_pContext, originalNode, strName, &hMockNode);
05598 XN_IS_STATUS_OK(nRetVal);
05599
05600 mockNode.TakeOwnership(hMockNode);
05601
05602 return (XN_STATUS_OK);
05603 }
05604
05608 inline XnStatus CreateCodec(XnCodecID codecID, ProductionNode& initializerNode, Codec& codec)
05609 {
05610 XnStatus nRetVal = XN_STATUS_OK;
05611
05612 XnNodeHandle hCodec;
05613 nRetVal = xnCreateCodec(m_pContext, codecID, initializerNode.GetHandle(), &hCodec);
05614 XN_IS_STATUS_OK(nRetVal);
05615
05616 codec.TakeOwnership(hCodec);
05617
05618 return (XN_STATUS_OK);
05619 }
05620
05624 inline XnStatus AddRef()
05625 {
05626 return xnContextAddRef(m_pContext);
05627 }
05628
05632 inline void Release()
05633 {
05634 SetHandle(NULL);
05635 }
05636
05640 inline void XN_API_DEPRECATED("You may use Release() instead, or count on dtor") Shutdown()
05641 {
05642 if (m_pContext != NULL)
05643 {
05644 #pragma warning (push)
05645 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
05646 xnShutdown(m_pContext);
05647 #pragma warning (pop)
05648 m_pContext = NULL;
05649 }
05650 }
05651
05655 inline XnStatus AddLicense(const XnLicense& License)
05656 {
05657 return xnAddLicense(m_pContext, &License);
05658 }
05659
05663 inline XnStatus EnumerateLicenses(XnLicense*& aLicenses, XnUInt32& nCount) const
05664 {
05665 return xnEnumerateLicenses(m_pContext, &aLicenses, &nCount);
05666 }
05667
05671 inline static void FreeLicensesList(XnLicense aLicenses[])
05672 {
05673 xnFreeLicensesList(aLicenses);
05674 }
05675
05679 XnStatus EnumerateProductionTrees(XnProductionNodeType Type, const Query* pQuery, NodeInfoList& TreesList, EnumerationErrors* pErrors = NULL) const
05680 {
05681 XnStatus nRetVal = XN_STATUS_OK;
05682
05683 const XnNodeQuery* pInternalQuery = (pQuery != NULL) ? pQuery->GetUnderlyingObject() : NULL;
05684
05685 XnNodeInfoList* pList = NULL;
05686 nRetVal = xnEnumerateProductionTrees(m_pContext, Type, pInternalQuery, &pList, pErrors == NULL ? NULL : pErrors->GetUnderlying());
05687 XN_IS_STATUS_OK(nRetVal);
05688
05689 TreesList.ReplaceUnderlyingObject(pList);
05690
05691 return (XN_STATUS_OK);
05692 }
05693
05697 XnStatus CreateAnyProductionTree(XnProductionNodeType type, Query* pQuery, ProductionNode& node, EnumerationErrors* pErrors = NULL)
05698 {
05699 XnStatus nRetVal = XN_STATUS_OK;
05700
05701 XnNodeQuery* pInternalQuery = (pQuery != NULL) ? pQuery->GetUnderlyingObject() : NULL;
05702
05703 XnNodeHandle hNode;
05704 nRetVal = xnCreateAnyProductionTree(m_pContext, type, pInternalQuery, &hNode, pErrors == NULL ? NULL : pErrors->GetUnderlying());
05705 XN_IS_STATUS_OK(nRetVal);
05706
05707 node.TakeOwnership(hNode);
05708
05709 return (XN_STATUS_OK);
05710 }
05711
05715 XnStatus XN_API_DEPRECATED("Please use other overload") CreateProductionTree(NodeInfo& Tree)
05716 {
05717 XnStatus nRetVal = XN_STATUS_OK;
05718
05719 XnNodeHandle hNode;
05720 nRetVal = xnCreateProductionTree(m_pContext, Tree, &hNode);
05721 XN_IS_STATUS_OK(nRetVal);
05722
05723 Tree.m_bOwnerOfNode = TRUE;
05724
05725 return (XN_STATUS_OK);
05726 }
05727
05731 XnStatus CreateProductionTree(NodeInfo& Tree, ProductionNode& node)
05732 {
05733 XnStatus nRetVal = XN_STATUS_OK;
05734
05735 XnNodeHandle hNode;
05736 nRetVal = xnCreateProductionTree(m_pContext, Tree, &hNode);
05737 XN_IS_STATUS_OK(nRetVal);
05738
05739 node.TakeOwnership(hNode);
05740
05741 return (XN_STATUS_OK);
05742 }
05743
05747 XnStatus EnumerateExistingNodes(NodeInfoList& list) const
05748 {
05749 XnNodeInfoList* pList;
05750 XnStatus nRetVal = xnEnumerateExistingNodes(m_pContext, &pList);
05751 XN_IS_STATUS_OK(nRetVal);
05752
05753 list.ReplaceUnderlyingObject(pList);
05754
05755 return (XN_STATUS_OK);
05756 }
05757
05761 XnStatus EnumerateExistingNodes(NodeInfoList& list, XnProductionNodeType type) const
05762 {
05763 XnNodeInfoList* pList;
05764 XnStatus nRetVal = xnEnumerateExistingNodesByType(m_pContext, type, &pList);
05765 XN_IS_STATUS_OK(nRetVal);
05766
05767 list.ReplaceUnderlyingObject(pList);
05768
05769 return (XN_STATUS_OK);
05770 }
05771
05775 XnStatus FindExistingNode(XnProductionNodeType type, ProductionNode& node) const
05776 {
05777 XnStatus nRetVal = XN_STATUS_OK;
05778
05779 XnNodeHandle hNode;
05780 nRetVal = xnFindExistingRefNodeByType(m_pContext, type, &hNode);
05781 XN_IS_STATUS_OK(nRetVal);
05782
05783 node.TakeOwnership(hNode);
05784
05785 return (XN_STATUS_OK);
05786 }
05787
05791 XnStatus GetProductionNodeByName(const XnChar* strInstanceName, ProductionNode& node) const
05792 {
05793 XnStatus nRetVal = XN_STATUS_OK;
05794
05795 XnNodeHandle hNode;
05796 nRetVal = xnGetRefNodeHandleByName(m_pContext, strInstanceName, &hNode);
05797 XN_IS_STATUS_OK(nRetVal);
05798
05799 node.TakeOwnership(hNode);
05800
05801 return (XN_STATUS_OK);
05802 }
05803
05807 XnStatus GetProductionNodeInfoByName(const XnChar* strInstanceName, NodeInfo& nodeInfo) const
05808 {
05809 XnStatus nRetVal = XN_STATUS_OK;
05810
05811 XnNodeHandle hNode;
05812 nRetVal = xnGetRefNodeHandleByName(m_pContext, strInstanceName, &hNode);
05813 XN_IS_STATUS_OK(nRetVal);
05814
05815 xnProductionNodeRelease(hNode);
05816
05817 nodeInfo = NodeInfo(xnGetNodeInfo(hNode));
05818
05819 return (XN_STATUS_OK);
05820 }
05821
05825 inline XnStatus StartGeneratingAll()
05826 {
05827 return xnStartGeneratingAll(m_pContext);
05828 }
05829
05833 inline XnStatus StopGeneratingAll()
05834 {
05835 return xnStopGeneratingAll(m_pContext);
05836 }
05837
05841 inline XnStatus SetGlobalMirror(XnBool bMirror)
05842 {
05843 return xnSetGlobalMirror(m_pContext, bMirror);
05844 }
05845
05849 inline XnBool GetGlobalMirror()
05850 {
05851 return xnGetGlobalMirror(m_pContext);
05852 }
05853
05857 inline XnStatus GetGlobalErrorState()
05858 {
05859 return xnGetGlobalErrorState(m_pContext);
05860 }
05861
05865 inline XnStatus RegisterToErrorStateChange(XnErrorStateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
05866 {
05867 return xnRegisterToGlobalErrorStateChange(m_pContext, handler, pCookie, &hCallback);
05868 }
05869
05873 inline void UnregisterFromErrorStateChange(XnCallbackHandle hCallback)
05874 {
05875 xnUnregisterFromGlobalErrorStateChange(m_pContext, hCallback);
05876 }
05877
05881 inline XnStatus WaitAndUpdateAll()
05882 {
05883 return xnWaitAndUpdateAll(m_pContext);
05884 }
05885
05889 inline XnStatus WaitAnyUpdateAll()
05890 {
05891 return xnWaitAnyUpdateAll(m_pContext);
05892 }
05893
05897 inline XnStatus WaitOneUpdateAll(ProductionNode& node)
05898 {
05899 return xnWaitOneUpdateAll(m_pContext, node.GetHandle());
05900 }
05901
05905 inline XnStatus WaitNoneUpdateAll()
05906 {
05907 return xnWaitNoneUpdateAll(m_pContext);
05908 }
05909
05913 inline XnStatus AutoEnumerateOverSingleInput(NodeInfoList& List, XnProductionNodeDescription& description, const XnChar* strCreationInfo, XnProductionNodeType InputType, EnumerationErrors* pErrors, Query* pQuery = NULL) const
05914 {
05915 return xnAutoEnumerateOverSingleInput(m_pContext, List.GetUnderlyingObject(), &description, strCreationInfo, InputType, pErrors == NULL ? NULL : pErrors->GetUnderlying(), pQuery == NULL ? NULL : pQuery->GetUnderlyingObject());
05916 }
05917
05919 inline void SetHandle(XnContext* pContext)
05920 {
05921 if (m_pContext == pContext)
05922 {
05923 return;
05924 }
05925
05926 if (m_pContext != NULL)
05927 {
05928 if (m_bUsingDeprecatedAPI && m_bAllocated)
05929 {
05930
05931
05932 xnForceShutdown(m_pContext);
05933 }
05934 else
05935 {
05936 xnContextUnregisterFromShutdown(m_pContext, m_hShuttingDownCallback);
05937 xnContextRelease(m_pContext);
05938 }
05939 }
05940
05941 if (pContext != NULL)
05942 {
05943 XnStatus nRetVal = xnContextAddRef(pContext);
05944 XN_ASSERT(nRetVal == XN_STATUS_OK);
05945
05946 nRetVal = xnContextRegisterForShutdown(pContext, ContextShuttingDownCallback, this, &m_hShuttingDownCallback);
05947 XN_ASSERT(nRetVal == XN_STATUS_OK);
05948 }
05949
05950 m_pContext = pContext;
05951 }
05952
05953 inline void TakeOwnership(XnContext* pContext)
05954 {
05955 SetHandle(pContext);
05956
05957 if (pContext != NULL)
05958 {
05959 xnContextRelease(pContext);
05960 }
05961 }
05962
05963 private:
05964 static void XN_CALLBACK_TYPE ContextShuttingDownCallback(XnContext* , void* pCookie)
05965 {
05966 Context* pThis = (Context*)pCookie;
05967 pThis->m_pContext = NULL;
05968 }
05969
05970 XnContext* m_pContext;
05971 XnBool m_bUsingDeprecatedAPI;
05972 XnBool m_bAllocated;
05973 XnCallbackHandle m_hShuttingDownCallback;
05974 };
05975
05980 class Resolution
05981 {
05982 public:
05988 inline Resolution(XnResolution res) : m_Res(res)
05989 {
05990 m_nXRes = xnResolutionGetXRes(res);
05991 m_nYRes = xnResolutionGetYRes(res);
05992 m_strName = xnResolutionGetName(res);
05993 }
05994
06001 inline Resolution(XnUInt32 xRes, XnUInt32 yRes) : m_nXRes(xRes), m_nYRes(yRes)
06002 {
06003 m_Res = xnResolutionGetFromXYRes(xRes, yRes);
06004 m_strName = xnResolutionGetName(m_Res);
06005 }
06006
06012 inline Resolution(const XnChar* strName)
06013 {
06014 m_Res = xnResolutionGetFromName(strName);
06015 m_nXRes = xnResolutionGetXRes(m_Res);
06016 m_nYRes = xnResolutionGetYRes(m_Res);
06017 m_strName = xnResolutionGetName(m_Res);
06018 }
06019
06021 inline XnResolution GetResolution() const { return m_Res; }
06023 inline XnUInt32 GetXResolution() const { return m_nXRes; }
06025 inline XnUInt32 GetYResolution() const { return m_nYRes; }
06027 inline const XnChar* GetName() const { return m_strName; }
06028
06029 private:
06030 XnResolution m_Res;
06031 XnUInt32 m_nXRes;
06032 XnUInt32 m_nYRes;
06033 const XnChar* m_strName;
06034 };
06035
06036
06037
06038
06039 inline XnStatus NodeInfoList::FilterList(Context& context, Query& query)
06040 {
06041 return xnNodeQueryFilterList(context.GetUnderlyingObject(), query.GetUnderlyingObject(), m_pList);
06042 }
06043
06044 inline void ProductionNode::GetContext(Context& context) const
06045 {
06046 context.TakeOwnership(xnGetRefContextFromNodeHandle(GetHandle()));
06047 }
06048
06049 inline NodeInfoList& NodeInfo::GetNeededNodes() const
06050 {
06051 if (m_pNeededNodes == NULL)
06052 {
06053 XnNodeInfoList* pList = xnNodeInfoGetNeededNodes(m_pInfo);
06054 m_pNeededNodes = XN_NEW(NodeInfoList, pList);
06055 }
06056
06057 return *m_pNeededNodes;
06058 }
06059
06060 inline void NodeInfo::SetUnderlyingObject(XnNodeInfo* pInfo)
06061 {
06062 if (m_pNeededNodes != NULL)
06063 {
06064 XN_DELETE(m_pNeededNodes);
06065 }
06066
06067 m_bOwnerOfNode = FALSE;
06068 m_pInfo = pInfo;
06069 m_pNeededNodes = NULL;
06070 }
06071
06072 inline XnBool FrameSyncCapability::CanFrameSyncWith(Generator& other) const
06073 {
06074 return xnCanFrameSyncWith(GetHandle(), other.GetHandle());
06075 }
06076
06077 inline XnStatus FrameSyncCapability::FrameSyncWith(Generator& other)
06078 {
06079 return xnFrameSyncWith(GetHandle(), other.GetHandle());
06080 }
06081
06082 inline XnStatus FrameSyncCapability::StopFrameSyncWith(Generator& other)
06083 {
06084 return xnStopFrameSyncWith(GetHandle(), other.GetHandle());
06085 }
06086
06087 inline XnBool FrameSyncCapability::IsFrameSyncedWith(Generator& other) const
06088 {
06089 return xnIsFrameSyncedWith(GetHandle(), other.GetHandle());
06090 }
06091
06092 inline XnStatus NodeInfo::GetInstance(ProductionNode& node) const
06093 {
06094 if (m_pInfo == NULL)
06095 {
06096 return XN_STATUS_INVALID_OPERATION;
06097 }
06098
06099 XnNodeHandle hNode = xnNodeInfoGetRefHandle(m_pInfo);
06100 node.TakeOwnership(hNode);
06101
06102 if (m_bOwnerOfNode)
06103 {
06104 xnProductionNodeRelease(hNode);
06105 }
06106
06107 return (XN_STATUS_OK);
06108 }
06109
06110
06111
06112
06113
06114 inline XnStatus Device::Create(Context& context, Query* pQuery, EnumerationErrors* pErrors)
06115 {
06116 XnNodeHandle hNode;
06117 XnStatus nRetVal = xnCreateDevice(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06118 XN_IS_STATUS_OK(nRetVal);
06119 TakeOwnership(hNode);
06120 return (XN_STATUS_OK);
06121 }
06122
06123 inline XnStatus Recorder::Create(Context& context, const XnChar* strFormatName )
06124 {
06125 XnNodeHandle hNode;
06126 XnStatus nRetVal = xnCreateRecorder(context.GetUnderlyingObject(), strFormatName, &hNode);
06127 XN_IS_STATUS_OK(nRetVal);
06128 TakeOwnership(hNode);
06129 return (XN_STATUS_OK);
06130 }
06131
06132 inline XnStatus Player::Create(Context& context, const XnChar* strFormatName)
06133 {
06134 XnNodeHandle hNode;
06135 XnStatus nRetVal = xnCreatePlayer(context.GetUnderlyingObject(), strFormatName, &hNode);
06136 XN_IS_STATUS_OK(nRetVal);
06137 TakeOwnership(hNode);
06138 return (XN_STATUS_OK);
06139 }
06140
06141 inline XnStatus DepthGenerator::Create(Context& context, Query* pQuery, EnumerationErrors* pErrors)
06142 {
06143 XnNodeHandle hNode;
06144 XnStatus nRetVal = xnCreateDepthGenerator(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06145 XN_IS_STATUS_OK(nRetVal);
06146 TakeOwnership(hNode);
06147 return (XN_STATUS_OK);
06148 }
06149
06150 inline XnStatus MockDepthGenerator::Create(Context& context, const XnChar* strName )
06151 {
06152 XnNodeHandle hNode;
06153 XnStatus nRetVal = xnCreateMockNode(context.GetUnderlyingObject(), XN_NODE_TYPE_DEPTH, strName, &hNode);
06154 XN_IS_STATUS_OK(nRetVal);
06155 TakeOwnership(hNode);
06156 return (XN_STATUS_OK);
06157 }
06158
06159 inline XnStatus MockDepthGenerator::CreateBasedOn(DepthGenerator& other, const XnChar* strName )
06160 {
06161 Context context;
06162 other.GetContext(context);
06163 XnNodeHandle hNode;
06164 XnStatus nRetVal = xnCreateMockNodeBasedOn(context.GetUnderlyingObject(), other.GetHandle(), strName, &hNode);
06165 XN_IS_STATUS_OK(nRetVal);
06166 TakeOwnership(hNode);
06167 return (XN_STATUS_OK);
06168 }
06169
06170 inline XnStatus ImageGenerator::Create(Context& context, Query* pQuery, EnumerationErrors* pErrors)
06171 {
06172 XnNodeHandle hNode;
06173 XnStatus nRetVal = xnCreateImageGenerator(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06174 XN_IS_STATUS_OK(nRetVal);
06175 TakeOwnership(hNode);
06176 return (XN_STATUS_OK);
06177 }
06178
06179 inline XnStatus MockImageGenerator::Create(Context& context, const XnChar* strName )
06180 {
06181 XnNodeHandle hNode;
06182 XnStatus nRetVal = xnCreateMockNode(context.GetUnderlyingObject(), XN_NODE_TYPE_IMAGE, strName, &hNode);
06183 XN_IS_STATUS_OK(nRetVal);
06184 TakeOwnership(hNode);
06185 return (XN_STATUS_OK);
06186 }
06187
06188 inline XnStatus MockImageGenerator::CreateBasedOn(ImageGenerator& other, const XnChar* strName )
06189 {
06190 Context context;
06191 other.GetContext(context);
06192 XnNodeHandle hNode;
06193 XnStatus nRetVal = xnCreateMockNodeBasedOn(context.GetUnderlyingObject(), other.GetHandle(), strName, &hNode);
06194 XN_IS_STATUS_OK(nRetVal);
06195 TakeOwnership(hNode);
06196 return (XN_STATUS_OK);
06197 }
06198
06199 inline XnStatus IRGenerator::Create(Context& context, Query* pQuery, EnumerationErrors* pErrors)
06200 {
06201 XnNodeHandle hNode;
06202 XnStatus nRetVal = xnCreateIRGenerator(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06203 XN_IS_STATUS_OK(nRetVal);
06204 TakeOwnership(hNode);
06205 return (XN_STATUS_OK);
06206 }
06207
06208 inline XnStatus MockIRGenerator::Create(Context& context, const XnChar* strName )
06209 {
06210 XnNodeHandle hNode;
06211 XnStatus nRetVal = xnCreateMockNode(context.GetUnderlyingObject(), XN_NODE_TYPE_IR, strName, &hNode);
06212 XN_IS_STATUS_OK(nRetVal);
06213 TakeOwnership(hNode);
06214 return (XN_STATUS_OK);
06215 }
06216
06217 inline XnStatus MockIRGenerator::CreateBasedOn(IRGenerator& other, const XnChar* strName )
06218 {
06219 Context context;
06220 other.GetContext(context);
06221 XnNodeHandle hNode;
06222 XnStatus nRetVal = xnCreateMockNodeBasedOn(context.GetUnderlyingObject(), other.GetHandle(), strName, &hNode);
06223 XN_IS_STATUS_OK(nRetVal);
06224 TakeOwnership(hNode);
06225 return (XN_STATUS_OK);
06226 }
06227
06228 inline XnStatus GestureGenerator::Create(Context& context, Query* pQuery, EnumerationErrors* pErrors)
06229 {
06230 XnNodeHandle hNode;
06231 XnStatus nRetVal = xnCreateGestureGenerator(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06232 XN_IS_STATUS_OK(nRetVal);
06233 TakeOwnership(hNode);
06234 return (XN_STATUS_OK);
06235 }
06236
06237 inline XnStatus SceneAnalyzer::Create(Context& context, Query* pQuery, EnumerationErrors* pErrors)
06238 {
06239
06240 XnNodeHandle hNode;
06241 XnStatus nRetVal = xnCreateSceneAnalyzer(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06242 XN_IS_STATUS_OK(nRetVal);
06243 TakeOwnership(hNode);
06244 return (XN_STATUS_OK);
06245 }
06246
06247 inline XnStatus HandsGenerator::Create(Context& context, Query* pQuery, EnumerationErrors* pErrors)
06248 {
06249 XnNodeHandle hNode;
06250 XnStatus nRetVal = xnCreateHandsGenerator(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06251 XN_IS_STATUS_OK(nRetVal);
06252 TakeOwnership(hNode);
06253 return (XN_STATUS_OK);
06254 }
06255
06256 inline XnStatus UserGenerator::Create(Context& context, Query* pQuery, EnumerationErrors* pErrors)
06257 {
06258 XnNodeHandle hNode;
06259 XnStatus nRetVal = xnCreateUserGenerator(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06260 XN_IS_STATUS_OK(nRetVal);
06261 TakeOwnership(hNode);
06262 return (XN_STATUS_OK);
06263 }
06264
06265 inline XnStatus AudioGenerator::Create(Context& context, Query* pQuery, EnumerationErrors* pErrors)
06266 {
06267 XnNodeHandle hNode;
06268 XnStatus nRetVal = xnCreateAudioGenerator(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06269 XN_IS_STATUS_OK(nRetVal);
06270 TakeOwnership(hNode);
06271 return (XN_STATUS_OK);
06272 }
06273
06274 inline XnStatus MockAudioGenerator::Create(Context& context, const XnChar* strName )
06275 {
06276 XnNodeHandle hNode;
06277 XnStatus nRetVal = xnCreateMockNode(context.GetUnderlyingObject(), XN_NODE_TYPE_AUDIO, strName, &hNode);
06278 XN_IS_STATUS_OK(nRetVal);
06279 TakeOwnership(hNode);
06280 return (XN_STATUS_OK);
06281 }
06282
06283 inline XnStatus MockAudioGenerator::CreateBasedOn(AudioGenerator& other, const XnChar* strName )
06284 {
06285 Context context;
06286 other.GetContext(context);
06287 XnNodeHandle hNode;
06288 XnStatus nRetVal = xnCreateMockNodeBasedOn(context.GetUnderlyingObject(), other.GetHandle(), strName, &hNode);
06289 XN_IS_STATUS_OK(nRetVal);
06290 TakeOwnership(hNode);
06291 return (XN_STATUS_OK);
06292 }
06293
06294 inline XnStatus MockRawGenerator::Create(Context& context, const XnChar* strName )
06295 {
06296 XnNodeHandle hNode;
06297 XnStatus nRetVal = xnCreateMockNode(context.GetUnderlyingObject(), XN_NODE_TYPE_GENERATOR, strName, &hNode);
06298 XN_IS_STATUS_OK(nRetVal);
06299 TakeOwnership(hNode);
06300 return (XN_STATUS_OK);
06301 }
06302
06303 inline XnStatus Codec::Create(Context& context, XnCodecID codecID, ProductionNode& initializerNode)
06304 {
06305 XnNodeHandle hNode;
06306 XnStatus nRetVal = xnCreateCodec(context.GetUnderlyingObject(), codecID, initializerNode.GetHandle(), &hNode);
06307 XN_IS_STATUS_OK(nRetVal);
06308 TakeOwnership(hNode);
06309 return (XN_STATUS_OK);
06310 }
06311
06312 inline XnStatus ScriptNode::Run(EnumerationErrors* pErrors)
06313 {
06314 return xnScriptNodeRun(GetHandle(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06315 }
06316
06317
06318
06319
06320
06324 inline void GetVersion(XnVersion& Version)
06325 {
06326 xnGetVersion(&Version);
06327 }
06328
06329
06330
06331
06332
06333 class StateChangedCallbackTranslator
06334 {
06335 public:
06336 StateChangedCallbackTranslator(StateChangedHandler handler, void* pCookie) : m_UserHandler(handler), m_pUserCookie(pCookie), m_hCallback(NULL) {}
06337
06338 XnStatus Register(_XnRegisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode)
06339 {
06340 return xnFunc(hNode, StateChangedCallback, this, &m_hCallback);
06341 }
06342
06343 void Unregister(_XnUnregisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode)
06344 {
06345 xnFunc(hNode, m_hCallback);
06346 }
06347
06348 static XnStatus RegisterToUnderlying(_XnRegisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode, StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
06349 {
06350 XnStatus nRetVal = XN_STATUS_OK;
06351
06352 StateChangedCallbackTranslator* pTrans;
06353 XN_VALIDATE_NEW(pTrans, StateChangedCallbackTranslator, handler, pCookie);
06354
06355 nRetVal = pTrans->Register(xnFunc, hNode);
06356 if (nRetVal != XN_STATUS_OK)
06357 {
06358 XN_DELETE(pTrans);
06359 return (nRetVal);
06360 }
06361
06362 hCallback = pTrans;
06363
06364 return (XN_STATUS_OK);
06365 }
06366
06367 static XnStatus UnregisterFromUnderlying(_XnUnregisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode, XnCallbackHandle hCallback)
06368 {
06369 StateChangedCallbackTranslator* pTrans = (StateChangedCallbackTranslator*)hCallback;
06370 pTrans->Unregister(xnFunc, hNode);
06371 XN_DELETE(pTrans);
06372 return XN_STATUS_OK;
06373 }
06374
06375 private:
06376 friend class GeneralIntCapability;
06377
06378 typedef struct StateChangeCookie
06379 {
06380 StateChangedHandler userHandler;
06381 void* pUserCookie;
06382 XnCallbackHandle hCallback;
06383 } StateChangeCookie;
06384
06385 static void XN_CALLBACK_TYPE StateChangedCallback(XnNodeHandle hNode, void* pCookie)
06386 {
06387 StateChangedCallbackTranslator* pTrans = (StateChangedCallbackTranslator*)pCookie;
06388 ProductionNode node(hNode);
06389 pTrans->m_UserHandler(node, pTrans->m_pUserCookie);
06390 }
06391
06392 StateChangedHandler m_UserHandler;
06393 void* m_pUserCookie;
06394 XnCallbackHandle m_hCallback;
06395 };
06396
06397 static XnStatus _RegisterToStateChange(_XnRegisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode, StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
06398 {
06399 return StateChangedCallbackTranslator::RegisterToUnderlying(xnFunc, hNode, handler, pCookie, hCallback);
06400 }
06401
06402 static void _UnregisterFromStateChange(_XnUnregisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode, XnCallbackHandle hCallback)
06403 {
06404 StateChangedCallbackTranslator::UnregisterFromUnderlying(xnFunc, hNode, hCallback);
06405 }
06406
06407 inline XnStatus GeneralIntCapability::RegisterToValueChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
06408 {
06409 XnStatus nRetVal = XN_STATUS_OK;
06410
06411 StateChangedCallbackTranslator* pTrans;
06412 XN_VALIDATE_NEW(pTrans, StateChangedCallbackTranslator, handler, pCookie);
06413
06414 nRetVal = xnRegisterToGeneralIntValueChange(GetHandle(), m_strCap, pTrans->StateChangedCallback, pTrans, &pTrans->m_hCallback);
06415 if (nRetVal != XN_STATUS_OK)
06416 {
06417 XN_DELETE(pTrans);
06418 return (nRetVal);
06419 }
06420
06421 hCallback = pTrans;
06422
06423 return (XN_STATUS_OK);
06424 }
06425
06426 inline void GeneralIntCapability::UnregisterFromValueChange(XnCallbackHandle hCallback)
06427 {
06428 StateChangedCallbackTranslator* pTrans = (StateChangedCallbackTranslator*)hCallback;
06429 xnUnregisterFromGeneralIntValueChange(GetHandle(), m_strCap, pTrans->m_hCallback);
06430 XN_DELETE(pTrans);
06431 }
06432
06434 };
06435
06436 #endif // __XN_CPP_WRAPPER_H__