 |
OpenNI 1.5.4
|
XnCppWrapper.h
Go to the documentation of this file.
00001 /**************************************************************************** 00002 * * 00003 * OpenNI 1.x Alpha * 00004 * Copyright (C) 2011 PrimeSense Ltd. * 00005 * * 00006 * This file is part of OpenNI. * 00007 * * 00008 * OpenNI is free software: you can redistribute it and/or modify * 00009 * it under the terms of the GNU Lesser General Public License as published * 00010 * by the Free Software Foundation, either version 3 of the License, or * 00011 * (at your option) any later version. * 00012 * * 00013 * OpenNI is distributed in the hope that it will be useful, * 00014 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 00015 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * 00016 * GNU Lesser General Public License for more details. * 00017 * * 00018 * You should have received a copy of the GNU Lesser General Public License * 00019 * along with OpenNI. If not, see <http://www.gnu.org/licenses/>. * 00020 * * 00021 ****************************************************************************/ 00022 #ifndef __XN_CPP_WRAPPER_H__ 00023 #define __XN_CPP_WRAPPER_H__ 00024 00025 //--------------------------------------------------------------------------- 00026 // Includes 00027 //--------------------------------------------------------------------------- 00028 #include <XnOpenNI.h> 00029 #include <XnCodecIDs.h> 00030 00031 //--------------------------------------------------------------------------- 00032 // Types 00033 //--------------------------------------------------------------------------- 00034 namespace xn 00035 { 00036 //--------------------------------------------------------------------------- 00037 // Forward Declarations 00038 //--------------------------------------------------------------------------- 00039 class ProductionNode; 00040 class EnumerationErrors; 00041 class NodeInfo; 00042 class NodeInfoList; 00043 class Context; 00044 class Query; 00045 class Generator; 00046 00072 //--------------------------------------------------------------------------- 00073 // Types 00074 //--------------------------------------------------------------------------- 00075 00101 typedef void (XN_CALLBACK_TYPE* StateChangedHandler)(ProductionNode& node, void* pCookie); 00102 00103 //--------------------------------------------------------------------------- 00104 // Internal stuff 00105 //--------------------------------------------------------------------------- 00106 typedef XnStatus (*_XnRegisterStateChangeFuncPtr)(XnNodeHandle hNode, XnStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback); 00107 typedef void (*_XnUnregisterStateChangeFuncPtr)(XnNodeHandle hNode, XnCallbackHandle hCallback); 00108 00109 static XnStatus _RegisterToStateChange(_XnRegisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode, StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback); 00110 static void _UnregisterFromStateChange(_XnUnregisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode, XnCallbackHandle hCallback); 00111 00112 //--------------------------------------------------------------------------- 00113 // Some Utilities 00114 //--------------------------------------------------------------------------- 00119 class Version 00120 { 00121 public: 00122 Version(const XnVersion& version) : m_version(version) {} 00123 Version(XnUInt8 nMajor, XnUInt8 nMinor, XnUInt16 nMaintenance, XnUInt32 nBuild) 00124 { 00125 m_version.nMajor = nMajor; 00126 m_version.nMinor = nMinor; 00127 m_version.nMaintenance = nMaintenance; 00128 m_version.nBuild = nBuild; 00129 } 00130 00131 bool operator==(const Version& other) const 00132 { 00133 return (xnVersionCompare(&m_version, &other.m_version) == 0); 00134 } 00135 bool operator!=(const Version& other) const 00136 { 00137 return (xnVersionCompare(&m_version, &other.m_version) != 0); 00138 } 00139 bool operator<(const Version& other) const 00140 { 00141 return (xnVersionCompare(&m_version, &other.m_version) < 0); 00142 } 00143 bool operator<=(const Version& other) const 00144 { 00145 return (xnVersionCompare(&m_version, &other.m_version) <= 0); 00146 } 00147 bool operator>(const Version& other) const 00148 { 00149 return (xnVersionCompare(&m_version, &other.m_version) > 0); 00150 } 00151 bool operator>=(const Version& other) const 00152 { 00153 return (xnVersionCompare(&m_version, &other.m_version) >= 0); 00154 } 00155 00156 static Version Current() 00157 { 00158 XnVersion version; 00159 xnGetVersion(&version); 00160 return Version(version); 00161 } 00162 00163 XnUInt8 Major() const { return m_version.nMajor; } 00164 XnUInt8 Minor() const { return m_version.nMinor; } 00165 XnUInt16 Maintenance() const { return m_version.nMaintenance; } 00166 XnUInt32 Build() const { return m_version.nBuild; } 00167 00168 XnUInt8& Major() { return m_version.nMajor; } 00169 XnUInt8& Minor() { return m_version.nMinor; } 00170 XnUInt16& Maintenance() { return m_version.nMaintenance; } 00171 XnUInt32& Build() { return m_version.nBuild; } 00172 00173 const XnVersion* GetUnderlying() const { return &m_version; } 00174 XnVersion* GetUnderlying() { return &m_version; } 00175 00176 private: 00177 XnVersion m_version; 00178 }; 00179 00180 //--------------------------------------------------------------------------- 00181 // Meta Data 00182 //--------------------------------------------------------------------------- 00183 00198 class OutputMetaData 00199 { 00200 public: 00206 inline OutputMetaData(const XnUInt8** ppData) : m_ppData(ppData), m_nAllocatedSize(0), m_pAllocatedData(NULL) 00207 { 00208 xnOSMemSet(&m_output, 0, sizeof(XnOutputMetaData)); 00209 } 00210 00214 virtual ~OutputMetaData() { Free(); } 00215 00219 inline XnUInt64 Timestamp() const { return m_output.nTimestamp; } 00220 00224 inline XnUInt64& Timestamp() { return m_output.nTimestamp; } 00225 00230 inline XnUInt32 FrameID() const { return m_output.nFrameID; } 00231 00236 inline XnUInt32& FrameID() { return m_output.nFrameID; } 00237 00246 inline XnUInt32 DataSize() const { return m_output.nDataSize; } 00247 00256 inline XnUInt32& DataSize() { return m_output.nDataSize; } 00257 00262 inline XnBool IsDataNew() const { return m_output.bIsNew; } 00263 00268 inline XnBool& IsDataNew() { return m_output.bIsNew; } 00269 00273 inline const XnOutputMetaData* GetUnderlying() const { return &m_output; } 00277 inline XnOutputMetaData* GetUnderlying() { return &m_output; } 00278 00283 inline const XnUInt8* Data() const { return *m_ppData; } 00288 inline const XnUInt8*& Data() { return *m_ppData; } 00289 00293 inline XnUInt8* WritableData() 00294 { 00295 MakeDataWritable(); 00296 return m_pAllocatedData; 00297 } 00298 00307 XnStatus AllocateData(XnUInt32 nBytes) 00308 { 00309 if (nBytes > m_nAllocatedSize) 00310 { 00311 // reallocate 00312 XnUInt8* pData = (XnUInt8*)xnOSMallocAligned(nBytes, XN_DEFAULT_MEM_ALIGN); 00313 XN_VALIDATE_ALLOC_PTR(pData); 00314 00315 // allocation succeeded, replace 00316 Free(); 00317 m_pAllocatedData = pData; 00318 m_nAllocatedSize = nBytes; 00319 } 00320 00321 DataSize() = nBytes; 00322 *m_ppData = m_pAllocatedData; 00323 00324 return XN_STATUS_OK; 00325 } 00326 00330 void Free() 00331 { 00332 if (m_nAllocatedSize != 0) 00333 { 00334 xnOSFreeAligned(m_pAllocatedData); 00335 m_pAllocatedData = NULL; 00336 m_nAllocatedSize = 0; 00337 } 00338 } 00339 00344 XnStatus MakeDataWritable() 00345 { 00346 XnStatus nRetVal = XN_STATUS_OK; 00347 00348 // check data isn't already writable 00349 if (Data() != m_pAllocatedData || DataSize() > m_nAllocatedSize) 00350 { 00351 const XnUInt8* pOrigData = *m_ppData; 00352 00353 nRetVal = AllocateData(DataSize()); 00354 XN_IS_STATUS_OK(nRetVal); 00355 00356 if (pOrigData != NULL) 00357 { 00358 xnOSMemCopy(m_pAllocatedData, pOrigData, DataSize()); 00359 } 00360 else 00361 { 00362 xnOSMemSet(m_pAllocatedData, 0, DataSize()); 00363 } 00364 } 00365 00366 return (XN_STATUS_OK); 00367 } 00368 00369 protected: 00370 XnUInt8* m_pAllocatedData; 00371 00372 private: 00373 XnOutputMetaData m_output; 00374 00375 const XnUInt8** m_ppData; 00376 XnUInt32 m_nAllocatedSize; 00377 }; 00378 00391 class MapMetaData : public OutputMetaData 00392 { 00393 public: 00400 inline MapMetaData(XnPixelFormat format, const XnUInt8** ppData) : OutputMetaData(ppData) 00401 { 00402 xnOSMemSet(&m_map, 0, sizeof(XnMapMetaData)); 00403 m_map.pOutput = OutputMetaData::GetUnderlying(); 00404 m_map.PixelFormat = format; 00405 } 00406 00412 inline XnUInt32 XRes() const { return m_map.Res.X; } 00418 inline XnUInt32& XRes() { return m_map.Res.X; } 00419 00425 inline XnUInt32 YRes() const { return m_map.Res.Y; } 00431 inline XnUInt32& YRes() { return m_map.Res.Y; } 00432 00441 inline XnUInt32 XOffset() const { return m_map.Offset.X; } 00450 inline XnUInt32& XOffset() { return m_map.Offset.X; } 00451 00460 inline XnUInt32 YOffset() const { return m_map.Offset.Y; } 00469 inline XnUInt32& YOffset() { return m_map.Offset.Y; } 00470 00475 inline XnUInt32 FullXRes() const { return m_map.FullRes.X; } 00476 00477 00482 inline XnUInt32& FullXRes() { return m_map.FullRes.X; } 00483 00487 inline XnUInt32 FullYRes() const { return m_map.FullRes.Y; } 00491 inline XnUInt32& FullYRes() { return m_map.FullRes.Y; } 00492 00496 inline XnUInt32 FPS() const { return m_map.nFPS; } 00500 inline XnUInt32& FPS() { return m_map.nFPS; } 00501 00505 inline XnPixelFormat PixelFormat() const { return m_map.PixelFormat; } 00506 00510 inline const XnMapMetaData* GetUnderlying() const { return &m_map; } 00514 inline XnMapMetaData* GetUnderlying() { return &m_map; } 00515 00519 inline XnUInt32 BytesPerPixel() const 00520 { 00521 switch (PixelFormat()) 00522 { 00523 case XN_PIXEL_FORMAT_RGB24: 00524 return sizeof(XnRGB24Pixel); 00525 case XN_PIXEL_FORMAT_YUV422: 00526 return sizeof(XnYUV422DoublePixel)/2; 00527 case XN_PIXEL_FORMAT_GRAYSCALE_8_BIT: 00528 return sizeof(XnGrayscale8Pixel); 00529 case XN_PIXEL_FORMAT_GRAYSCALE_16_BIT: 00530 return sizeof(XnGrayscale16Pixel); 00531 case XN_PIXEL_FORMAT_MJPEG: 00532 return 2; 00533 default: 00534 XN_ASSERT(FALSE); 00535 return 0; 00536 } 00537 } 00538 00545 XnStatus AllocateData(XnUInt32 nXRes, XnUInt32 nYRes) 00546 { 00547 XnStatus nRetVal = XN_STATUS_OK; 00548 00549 XnUInt32 nSize = nXRes * nYRes * BytesPerPixel(); 00550 nRetVal = OutputMetaData::AllocateData(nSize); 00551 XN_IS_STATUS_OK(nRetVal); 00552 00553 FullXRes() = XRes() = nXRes; 00554 FullYRes() = YRes() = nYRes; 00555 XOffset() = YOffset() = 0; 00556 00557 return (XN_STATUS_OK); 00558 } 00559 00568 XnStatus ReAdjust(XnUInt32 nXRes, XnUInt32 nYRes, const XnUInt8* pExternalBuffer) 00569 { 00570 XnStatus nRetVal = XN_STATUS_OK; 00571 00572 if (pExternalBuffer == NULL) 00573 { 00574 nRetVal = AllocateData(nXRes, nYRes); 00575 XN_IS_STATUS_OK(nRetVal); 00576 } 00577 else 00578 { 00579 FullXRes() = XRes() = nXRes; 00580 FullYRes() = YRes() = nYRes; 00581 XOffset() = YOffset() = 0; 00582 Data() = pExternalBuffer; 00583 DataSize() = nXRes * nYRes * BytesPerPixel(); 00584 } 00585 00586 return (XN_STATUS_OK); 00587 } 00588 00589 protected: 00590 XnPixelFormat& PixelFormatImpl() { return m_map.PixelFormat; } 00591 00592 private: 00593 // block copy ctor and assignment operator 00594 MapMetaData& operator=(const MapMetaData&); 00595 inline MapMetaData(const MapMetaData& other); 00596 00597 // Members 00598 XnMapMetaData m_map; 00599 }; 00600 00608 template<class _pixelType> 00609 class Map 00610 { 00611 public: 00612 inline Map(_pixelType*& pData, XnUInt32& nXRes, XnUInt32 &nYRes) : 00613 m_pData(pData), m_nXRes(nXRes), m_nYRes(nYRes) 00614 {} 00615 00623 inline XnUInt32 XRes() const { return m_nXRes; } 00631 inline XnUInt32 YRes() const { return m_nYRes; } 00632 00644 inline const _pixelType& operator[](XnUInt32 nIndex) const 00645 { 00646 XN_ASSERT(nIndex < (m_nXRes * m_nYRes)); 00647 return m_pData[nIndex]; 00648 } 00660 inline _pixelType& operator[](XnUInt32 nIndex) 00661 { 00662 XN_ASSERT(nIndex < (m_nXRes *m_nYRes)); 00663 return m_pData[nIndex]; 00664 } 00665 00674 inline const _pixelType& operator()(XnUInt32 x, XnUInt32 y) const 00675 { 00676 XN_ASSERT(x < m_nXRes && y < m_nYRes); 00677 return m_pData[y*m_nXRes + x]; 00678 } 00687 inline _pixelType& operator()(XnUInt32 x, XnUInt32 y) 00688 { 00689 XN_ASSERT(x < m_nXRes && y < m_nYRes); 00690 return m_pData[y*m_nXRes + x]; 00691 } 00692 00693 private: 00694 /* block copy ctor and assignment operator */ 00695 Map(const Map& other); 00696 Map& operator=(const Map&); 00697 00698 _pixelType*& m_pData; 00699 XnUInt32& m_nXRes; 00700 XnUInt32& m_nYRes; 00701 }; 00702 00707 typedef Map<XnDepthPixel> DepthMap; 00709 typedef Map<XnUInt8> ImageMap; 00711 typedef Map<XnRGB24Pixel> RGB24Map; 00713 typedef Map<XnGrayscale16Pixel> Grayscale16Map; 00715 typedef Map<XnGrayscale8Pixel> Grayscale8Map; 00717 typedef Map<XnIRPixel> IRMap; 00719 typedef Map<XnLabel> LabelMap; 00754 class DepthMetaData : public MapMetaData 00755 { 00756 public: 00760 inline DepthMetaData() : 00761 MapMetaData(XN_PIXEL_FORMAT_GRAYSCALE_16_BIT, (const XnUInt8**)&m_depth.pData), 00762 m_depthMap(const_cast<XnDepthPixel*&>(m_depth.pData), MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y), 00763 m_writableDepthMap((XnDepthPixel*&)m_pAllocatedData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y) 00764 { 00765 xnOSMemSet(&m_depth, 0, sizeof(XnDepthMetaData)); 00766 m_depth.pMap = MapMetaData::GetUnderlying(); 00767 } 00768 00776 inline void InitFrom(const DepthMetaData& other) 00777 { 00778 xnCopyDepthMetaData(&m_depth, &other.m_depth); 00779 } 00780 00791 inline XnStatus InitFrom(const DepthMetaData& other, XnUInt32 nXRes, XnUInt32 nYRes, const XnDepthPixel* pExternalBuffer) 00792 { 00793 InitFrom(other); 00794 return ReAdjust(nXRes, nYRes, pExternalBuffer); 00795 } 00796 00803 XnStatus CopyFrom(const DepthMetaData& other) 00804 { 00805 // copy props 00806 InitFrom(other); 00807 // and make a copy of the data (this will allocate and copy data) 00808 return MakeDataWritable(); 00809 } 00810 00814 XnStatus ReAdjust(XnUInt32 nXRes, XnUInt32 nYRes, const XnDepthPixel* pExternalBuffer = NULL) 00815 { 00816 return MapMetaData::ReAdjust(nXRes, nYRes, (const XnUInt8*)pExternalBuffer); 00817 } 00818 00824 inline XnDepthPixel ZRes() const { return m_depth.nZRes; } 00830 inline XnDepthPixel& ZRes() { return m_depth.nZRes; } 00831 00844 inline const XnDepthPixel* Data() const { return (const XnDepthPixel*)MapMetaData::Data(); } 00857 inline const XnDepthPixel*& Data() { return (const XnDepthPixel*&)MapMetaData::Data(); } 00858 00859 00863 inline XnDepthPixel* WritableData() { return (XnDepthPixel*)MapMetaData::WritableData(); } 00864 00868 inline const xn::DepthMap& DepthMap() const { return m_depthMap; } 00872 inline xn::DepthMap& WritableDepthMap() 00873 { 00874 MakeDataWritable(); 00875 return m_writableDepthMap; 00876 } 00877 00883 inline const XnDepthPixel& operator[](XnUInt32 nIndex) const 00884 { 00885 XN_ASSERT(nIndex < (XRes()*YRes())); 00886 return Data()[nIndex]; 00887 } 00888 00895 inline const XnDepthPixel& operator()(XnUInt32 x, XnUInt32 y) const 00896 { 00897 XN_ASSERT(x < XRes() && y < YRes()); 00898 return Data()[y*XRes() + x]; 00899 } 00900 00904 inline const XnDepthMetaData* GetUnderlying() const { return &m_depth; } 00908 inline XnDepthMetaData* GetUnderlying() { return &m_depth; } 00909 00910 private: 00911 // block copy ctor and assignment operator (because we can't return errors in those) 00912 DepthMetaData(const DepthMetaData& other); 00913 DepthMetaData& operator=(const DepthMetaData&); 00914 00915 XnDepthMetaData m_depth; 00916 const xn::DepthMap m_depthMap; 00917 xn::DepthMap m_writableDepthMap; 00918 }; 00919 00946 class ImageMetaData : public MapMetaData 00947 { 00948 public: 00949 inline ImageMetaData() : 00950 MapMetaData(XN_PIXEL_FORMAT_RGB24, &m_image.pData), 00951 m_imageMap(const_cast<XnUInt8*&>(m_image.pData), MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y), 00952 m_writableImageMap((XnUInt8*&)m_pAllocatedData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y), 00953 m_rgb24Map((XnRGB24Pixel*&)m_image.pData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y), 00954 m_writableRgb24Map((XnRGB24Pixel*&)m_pAllocatedData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y), 00955 m_gray16Map((XnGrayscale16Pixel*&)m_image.pData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y), 00956 m_writableGray16Map((XnGrayscale16Pixel*&)m_pAllocatedData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y), 00957 m_gray8Map((XnGrayscale8Pixel*&)m_image.pData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y), 00958 m_writableGray8Map((XnGrayscale8Pixel*&)m_pAllocatedData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y) 00959 { 00960 xnOSMemSet(&m_image, 0, sizeof(XnImageMetaData)); 00961 m_image.pMap = MapMetaData::GetUnderlying(); 00962 } 00963 00971 inline void InitFrom(const ImageMetaData& other) 00972 { 00973 xnCopyImageMetaData(&m_image, &other.m_image); 00974 } 00975 00987 inline XnStatus InitFrom(const ImageMetaData& other, XnUInt32 nXRes, XnUInt32 nYRes, XnPixelFormat format, const XnUInt8* pExternalBuffer) 00988 { 00989 InitFrom(other); 00990 XnStatus nRetVal = ReAdjust(nXRes, nYRes, format, pExternalBuffer); 00991 XN_IS_STATUS_OK(nRetVal); 00992 PixelFormat() = format; 00993 return XN_STATUS_OK; 00994 } 00995 01003 inline XnStatus AllocateData(XnUInt32 nXRes, XnUInt32 nYRes, XnPixelFormat format) 01004 { 01005 XnPixelFormat origFormat = PixelFormat(); 01006 PixelFormat() = format; 01007 XnStatus nRetVal = MapMetaData::AllocateData(nXRes, nYRes); 01008 if (nRetVal != XN_STATUS_OK) 01009 { 01010 PixelFormat() = origFormat; 01011 return (nRetVal); 01012 } 01013 01014 return XN_STATUS_OK; 01015 } 01016 01022 inline XnStatus CopyFrom(const ImageMetaData& other) 01023 { 01024 // copy props 01025 xnCopyImageMetaData(&m_image, &other.m_image); 01026 // and make a copy of the data (this will allocate and copy data) 01027 return MakeDataWritable(); 01028 } 01029 01039 XnStatus ReAdjust(XnUInt32 nXRes, XnUInt32 nYRes, XnPixelFormat format, const XnUInt8* pExternalBuffer = NULL) 01040 { 01041 XnPixelFormat origFormat = PixelFormat(); 01042 PixelFormat() = format; 01043 XnStatus nRetVal = MapMetaData::ReAdjust(nXRes, nYRes, pExternalBuffer); 01044 if (nRetVal != XN_STATUS_OK) 01045 { 01046 PixelFormat() = origFormat; 01047 return (nRetVal); 01048 } 01049 01050 return XN_STATUS_OK; 01051 } 01052 01064 inline XnPixelFormat PixelFormat() const { return MapMetaData::PixelFormat(); } 01074 inline XnPixelFormat& PixelFormat() { return MapMetaData::PixelFormatImpl(); } 01075 01079 inline XnUInt8* WritableData() { return MapMetaData::WritableData(); } 01080 01085 inline const XnRGB24Pixel* RGB24Data() const { return (const XnRGB24Pixel*)MapMetaData::Data(); } 01090 inline const XnRGB24Pixel*& RGB24Data() { return (const XnRGB24Pixel*&)MapMetaData::Data(); } 01094 inline XnRGB24Pixel* WritableRGB24Data() { return (XnRGB24Pixel*)MapMetaData::WritableData(); } 01095 01101 inline const XnYUV422DoublePixel* YUV422Data() const { return (const XnYUV422DoublePixel*)MapMetaData::Data(); } 01107 inline const XnYUV422DoublePixel*& YUV422Data() { return (const XnYUV422DoublePixel*&)MapMetaData::Data(); } 01111 inline XnYUV422DoublePixel* WritableYUV422Data() { return (XnYUV422DoublePixel*)MapMetaData::WritableData(); } 01112 01117 inline const XnGrayscale8Pixel* Grayscale8Data() const { return (const XnGrayscale8Pixel*)MapMetaData::Data(); } 01122 inline const XnGrayscale8Pixel*& Grayscale8Data() { return (const XnGrayscale8Pixel*&)MapMetaData::Data(); } 01126 inline XnGrayscale8Pixel* WritableGrayscale8Data() { return (XnGrayscale8Pixel*)MapMetaData::WritableData(); } 01127 01132 inline const XnGrayscale16Pixel* Grayscale16Data() const { return (const XnGrayscale16Pixel*)MapMetaData::Data(); } 01137 inline const XnGrayscale16Pixel*& Grayscale16Data() { return (const XnGrayscale16Pixel*&)MapMetaData::Data(); } 01141 inline XnGrayscale16Pixel* WritableGrayscale16Data() { return (XnGrayscale16Pixel*)MapMetaData::WritableData(); } 01142 01146 inline const xn::ImageMap& ImageMap() const { return m_imageMap; } 01150 inline xn::ImageMap& WritableImageMap() { MakeDataWritable(); return m_writableImageMap; } 01151 01157 inline const xn::RGB24Map& RGB24Map() const { return m_rgb24Map; } 01161 inline xn::RGB24Map& WritableRGB24Map() { MakeDataWritable(); return m_writableRgb24Map; } 01162 01166 inline const xn::Grayscale8Map& Grayscale8Map() const { return m_gray8Map; } 01170 inline xn::Grayscale8Map& WritableGrayscale8Map() { MakeDataWritable(); return m_writableGray8Map; } 01171 01176 inline const xn::Grayscale16Map& Grayscale16Map() const { return m_gray16Map; } 01180 inline xn::Grayscale16Map& WritableGrayscale16Map() { MakeDataWritable(); return m_writableGray16Map; } 01181 01185 inline const XnImageMetaData* GetUnderlying() const { return &m_image; } 01189 inline XnImageMetaData* GetUnderlying() { return &m_image; } 01190 01191 private: 01192 // block copy ctor and assignment operator 01193 ImageMetaData(const ImageMetaData& other); 01194 ImageMetaData& operator=(const ImageMetaData&); 01195 01196 XnImageMetaData m_image; 01197 const xn::ImageMap m_imageMap; 01198 xn::ImageMap m_writableImageMap; 01199 const xn::RGB24Map m_rgb24Map; 01200 xn::RGB24Map m_writableRgb24Map; 01201 const xn::Grayscale16Map m_gray16Map; 01202 xn::Grayscale16Map m_writableGray16Map; 01203 const xn::Grayscale8Map m_gray8Map; 01204 xn::Grayscale8Map m_writableGray8Map; 01205 }; 01206 01216 class IRMetaData : public MapMetaData 01217 { 01218 public: 01219 inline IRMetaData() : 01220 MapMetaData(XN_PIXEL_FORMAT_GRAYSCALE_16_BIT, (const XnUInt8**)&m_ir.pData), 01221 m_irMap(const_cast<XnIRPixel*&>(m_ir.pData), MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y), 01222 m_writableIRMap((XnIRPixel*&)m_pAllocatedData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y) 01223 { 01224 xnOSMemSet(&m_ir, 0, sizeof(XnIRMetaData)); 01225 m_ir.pMap = MapMetaData::GetUnderlying(); 01226 } 01227 01235 inline void InitFrom(const IRMetaData& other) 01236 { 01237 xnCopyIRMetaData(&m_ir, &other.m_ir); 01238 } 01239 01249 inline XnStatus InitFrom(const IRMetaData& other, XnUInt32 nXRes, XnUInt32 nYRes, const XnIRPixel* pExternalBuffer) 01250 { 01251 InitFrom(other); 01252 return ReAdjust(nXRes, nYRes, pExternalBuffer); 01253 } 01254 01260 XnStatus CopyFrom(const IRMetaData& other) 01261 { 01262 // copy props 01263 xnCopyIRMetaData(&m_ir, &other.m_ir); 01264 // and make a copy of the data (this will allocate and copy data) 01265 return MakeDataWritable(); 01266 } 01267 01271 XnStatus ReAdjust(XnUInt32 nXRes, XnUInt32 nYRes, const XnIRPixel* pExternalBuffer = NULL) 01272 { 01273 return MapMetaData::ReAdjust(nXRes, nYRes, (const XnUInt8*)pExternalBuffer); 01274 } 01275 01288 inline const XnIRPixel* Data() const { return (const XnIRPixel*)MapMetaData::Data(); } 01301 inline const XnIRPixel*& Data() { return (const XnIRPixel*&)MapMetaData::Data(); } 01305 inline XnIRPixel* WritableData() { return (XnIRPixel*)MapMetaData::WritableData(); } 01306 01312 inline const XnIRPixel& operator[](XnUInt32 nIndex) const 01313 { 01314 XN_ASSERT(nIndex < (XRes()*YRes())); 01315 return Data()[nIndex]; 01316 } 01317 01324 inline const XnIRPixel& operator()(XnUInt32 x, XnUInt32 y) const 01325 { 01326 XN_ASSERT(x < XRes() && y < YRes()); 01327 return Data()[y*XRes() + x]; 01328 } 01329 01338 inline const xn::IRMap& IRMap() const { return m_irMap; } 01347 inline xn::IRMap& WritableIRMap() { MakeDataWritable(); return m_writableIRMap; } 01348 01352 inline const XnIRMetaData* GetUnderlying() const { return &m_ir; } 01356 inline XnIRMetaData* GetUnderlying() { return &m_ir; } 01357 01358 private: 01359 // block copy ctor and assignment operator 01360 IRMetaData(const IRMetaData& other); 01361 IRMetaData& operator=(const IRMetaData&); 01362 01363 XnIRMetaData m_ir; 01364 const xn::IRMap m_irMap; 01365 xn::IRMap m_writableIRMap; 01366 }; 01367 01374 class AudioMetaData : public OutputMetaData 01375 { 01376 public: 01377 XN_PRAGMA_START_DISABLED_WARNING_SECTION(XN_UNALIGNED_ADDRESS_WARNING_ID); 01378 inline AudioMetaData() : OutputMetaData(&m_audio.pData) 01379 { 01380 xnOSMemSet(&m_audio, 0, sizeof(XnAudioMetaData)); 01381 m_audio.pOutput = OutputMetaData::GetUnderlying(); 01382 } 01383 01384 XN_PRAGMA_STOP_DISABLED_WARNING_SECTION; 01385 01393 inline void InitFrom(const AudioMetaData& other) 01394 { 01395 xnCopyAudioMetaData(&m_audio, &other.m_audio); 01396 } 01397 01401 inline XnUInt8 NumberOfChannels() const { return m_audio.Wave.nChannels; } 01405 inline XnUInt8& NumberOfChannels() { return m_audio.Wave.nChannels; } 01406 01410 inline XnUInt32 SampleRate() const { return m_audio.Wave.nSampleRate; } 01414 inline XnUInt32& SampleRate() { return m_audio.Wave.nSampleRate; } 01415 01419 inline XnUInt16 BitsPerSample() const { return m_audio.Wave.nBitsPerSample; } 01423 inline XnUInt16& BitsPerSample() { return m_audio.Wave.nBitsPerSample; } 01424 01428 inline const XnAudioMetaData* GetUnderlying() const { return &m_audio; } 01432 inline XnAudioMetaData* GetUnderlying() { return &m_audio; } 01433 01434 private: 01435 // block copy ctor and assignment operator 01436 AudioMetaData(const AudioMetaData& other); 01437 AudioMetaData& operator=(const AudioMetaData&); 01438 01439 XnAudioMetaData m_audio; 01440 }; 01441 01450 class SceneMetaData : public MapMetaData 01451 { 01452 public: 01453 inline SceneMetaData() : 01454 MapMetaData(XN_PIXEL_FORMAT_GRAYSCALE_16_BIT, (const XnUInt8**)&m_scene.pData), 01455 m_labelMap(const_cast<XnLabel*&>(m_scene.pData), MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y), 01456 m_writableLabelMap((XnLabel*&)m_pAllocatedData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y) 01457 { 01458 xnOSMemSet(&m_scene, 0, sizeof(XnSceneMetaData)); 01459 m_scene.pMap = MapMetaData::GetUnderlying(); 01460 } 01461 01469 inline void InitFrom(const SceneMetaData& other) 01470 { 01471 xnCopySceneMetaData(&m_scene, &other.m_scene); 01472 } 01473 01483 inline XnStatus InitFrom(const SceneMetaData& other, XnUInt32 nXRes, XnUInt32 nYRes, const XnLabel* pExternalBuffer) 01484 { 01485 InitFrom(other); 01486 return ReAdjust(nXRes, nYRes, pExternalBuffer); 01487 } 01488 01494 XnStatus CopyFrom(const SceneMetaData& other) 01495 { 01496 // copy props 01497 xnCopySceneMetaData(&m_scene, &other.m_scene); 01498 // and make a copy of the data (this will allocate and copy data) 01499 return MakeDataWritable(); 01500 } 01501 01505 XnStatus ReAdjust(XnUInt32 nXRes, XnUInt32 nYRes, const XnLabel* pExternalBuffer = NULL) 01506 { 01507 return MapMetaData::ReAdjust(nXRes, nYRes, (const XnUInt8*)pExternalBuffer); 01508 } 01509 01523 inline const XnLabel* Data() const { return (const XnLabel*)MapMetaData::Data(); } 01537 inline const XnLabel*& Data() { return (const XnLabel*&)MapMetaData::Data(); } 01538 01542 inline XnLabel* WritableData() { return (XnLabel*)MapMetaData::WritableData(); } 01543 01547 inline const xn::LabelMap& LabelMap() const { return m_labelMap; } 01551 inline xn::LabelMap& WritableLabelMap() { MakeDataWritable(); return m_writableLabelMap; } 01552 01563 inline const XnLabel& operator[](XnUInt32 nIndex) const 01564 { 01565 XN_ASSERT(nIndex < (XRes()*YRes())); 01566 return Data()[nIndex]; 01567 } 01568 01580 inline const XnLabel& operator()(XnUInt32 x, XnUInt32 y) const 01581 { 01582 XN_ASSERT(x < XRes() && y < YRes()); 01583 return (*this)[y*XRes() + x]; 01584 } 01585 01589 inline const XnSceneMetaData* GetUnderlying() const { return &m_scene; } 01593 inline XnSceneMetaData* GetUnderlying() { return &m_scene; } 01594 01595 private: 01596 // block copy ctor and assignment operator 01597 SceneMetaData(const SceneMetaData& other); 01598 SceneMetaData& operator=(const SceneMetaData&); 01599 01600 XnSceneMetaData m_scene; 01601 const xn::LabelMap m_labelMap; 01602 xn::LabelMap m_writableLabelMap; 01603 }; 01604 01605 //--------------------------------------------------------------------------- 01606 // NodeWrapper 01607 //--------------------------------------------------------------------------- 01608 01628 class NodeWrapper 01629 { 01630 public: 01631 friend class Context; 01632 01638 inline NodeWrapper(XnNodeHandle hNode) : m_hNode(NULL), m_hShuttingDownCallback(NULL) 01639 { 01640 SetHandle(hNode); 01641 } 01642 01643 inline NodeWrapper(const NodeWrapper& other) : m_hNode(NULL), m_hShuttingDownCallback(NULL) 01644 { 01645 SetHandle(other.GetHandle()); 01646 } 01647 01648 inline NodeWrapper& operator=(const NodeWrapper& other) 01649 { 01650 SetHandle(other.GetHandle()); 01651 return *this; 01652 } 01653 01654 inline ~NodeWrapper() 01655 { 01656 SetHandle(NULL); 01657 } 01658 01659 inline operator XnNodeHandle() const { return GetHandle(); } 01660 01664 inline XnNodeHandle GetHandle() const { return m_hNode; } 01665 01671 inline XnBool operator==(const NodeWrapper& other) 01672 { 01673 return (GetHandle() == other.GetHandle()); 01674 } 01675 01681 inline XnBool operator!=(const NodeWrapper& other) 01682 { 01683 return (GetHandle() != other.GetHandle()); 01684 } 01685 01699 inline XnBool IsValid() const { return (GetHandle() != NULL); } 01700 01701 /* 01702 * @brief Gets the instance name of a node. Unless the application made a specific 01703 * request for a specific name, the name will be of the form: "Depth1", "Image2", etc. 01704 */ 01705 const XnChar* GetName() const {return xnGetNodeName(GetHandle()); } 01706 01711 inline XnStatus AddRef() { return xnProductionNodeAddRef(GetHandle()); } 01712 01717 inline void Release() 01718 { 01719 SetHandle(NULL); 01720 } 01721 01722 01726 inline void SetHandle(XnNodeHandle hNode) 01727 { 01728 if (m_hNode == hNode) 01729 { 01730 // Optimization: do nothing 01731 return; 01732 } 01733 01734 // check currently held node. If we're holding a node, release it 01735 if (m_hNode != NULL) 01736 { 01737 XnContext* pContext = xnGetRefContextFromNodeHandle(m_hNode); 01738 xnContextUnregisterFromShutdown(pContext, m_hShuttingDownCallback); 01739 xnContextRelease(pContext); 01740 xnProductionNodeRelease(m_hNode); 01741 } 01742 01743 // check new node handle, if it points to a node, add ref to it 01744 if (hNode != NULL) 01745 { 01746 XnStatus nRetVal = xnProductionNodeAddRef(hNode); 01747 XN_ASSERT(nRetVal == XN_STATUS_OK); 01748 XN_REFERENCE_VARIABLE(nRetVal); 01749 01750 XnContext* pContext = xnGetRefContextFromNodeHandle(hNode); 01751 01752 nRetVal = xnContextRegisterForShutdown(pContext, ContextShuttingDownCallback, this, &m_hShuttingDownCallback); 01753 XN_ASSERT(nRetVal == XN_STATUS_OK); 01754 01755 xnContextRelease(pContext); 01756 } 01757 01758 m_hNode = hNode; 01759 } 01760 01761 inline void TakeOwnership(XnNodeHandle hNode) 01762 { 01763 SetHandle(hNode); 01764 01765 if (hNode != NULL) 01766 { 01767 xnProductionNodeRelease(hNode); 01768 } 01769 } 01770 01772 inline XnStatus XN_API_DEPRECATED("Please use AddRef() instead.") Ref() { return AddRef(); } 01773 inline void XN_API_DEPRECATED("Please use Release() instead.") Unref() { Release(); } 01776 private: 01777 XnNodeHandle m_hNode; 01778 XnCallbackHandle m_hShuttingDownCallback; 01779 01780 static void XN_CALLBACK_TYPE ContextShuttingDownCallback(XnContext* /*pContext*/, void* pCookie) 01781 { 01782 NodeWrapper* pThis = (NodeWrapper*)pCookie; 01783 pThis->m_hNode = NULL; 01784 } 01785 }; 01786 01787 //--------------------------------------------------------------------------- 01788 // Node Info 01789 //--------------------------------------------------------------------------- 01790 01802 class NodeInfo 01803 { 01804 public: 01810 NodeInfo(XnNodeInfo* pInfo) : m_pNeededNodes(NULL), m_bOwnerOfNode(FALSE) 01811 { 01812 SetUnderlyingObject(pInfo); 01813 } 01814 01820 NodeInfo(const NodeInfo& other) : m_pNeededNodes(NULL), m_bOwnerOfNode(FALSE) 01821 { 01822 SetUnderlyingObject(other.m_pInfo); 01823 } 01824 01828 ~NodeInfo() 01829 { 01830 SetUnderlyingObject(NULL); 01831 } 01832 01838 inline NodeInfo& operator=(const NodeInfo& other) 01839 { 01840 SetUnderlyingObject(other.m_pInfo); 01841 return *this; 01842 } 01843 01847 inline operator XnNodeInfo*() 01848 { 01849 return m_pInfo; 01850 } 01851 01857 inline XnStatus SetInstanceName(const XnChar* strName) 01858 { 01859 return xnNodeInfoSetInstanceName(m_pInfo, strName); 01860 } 01861 01875 inline const XnProductionNodeDescription& GetDescription() const 01876 { 01877 return *xnNodeInfoGetDescription(m_pInfo); 01878 } 01879 01891 inline const XnChar* GetInstanceName() const 01892 { 01893 return xnNodeInfoGetInstanceName(m_pInfo); 01894 } 01895 01907 inline const XnChar* GetCreationInfo() const 01908 { 01909 return xnNodeInfoGetCreationInfo(m_pInfo); 01910 } 01911 01912 /* 01913 * @brief Gets the list of dependant nodes for this node alternative. 01914 * These are any other node alternatives that the node is dependant on. 01915 */ 01916 inline NodeInfoList& GetNeededNodes() const; 01917 01925 inline XnStatus GetInstance(ProductionNode& node) const; 01926 01931 inline const void* GetAdditionalData() const 01932 { 01933 return xnNodeInfoGetAdditionalData(m_pInfo); 01934 } 01935 01940 inline XnStatus GetTreeStringRepresentation(XnChar* csResultBuffer, XnUInt32 nBufferSize) const 01941 { 01942 return xnNodeInfoGetTreeStringRepresentation(m_pInfo, csResultBuffer, nBufferSize); 01943 } 01944 01945 private: 01946 inline void SetUnderlyingObject(XnNodeInfo* pInfo); 01947 01948 XnNodeInfo* m_pInfo; 01949 mutable NodeInfoList* m_pNeededNodes; 01950 XnBool m_bOwnerOfNode; // backwards compatibility 01951 friend class Context; 01952 }; 01953 01954 //--------------------------------------------------------------------------- 01955 // Query 01956 //--------------------------------------------------------------------------- 01957 01976 class Query 01977 { 01978 public: 01979 inline Query() : m_bAllocated(TRUE) 01980 { 01981 xnNodeQueryAllocate(&m_pQuery); 01982 } 01983 01984 inline Query(XnNodeQuery* pNodeQuery) : m_bAllocated(FALSE), m_pQuery(pNodeQuery) 01985 { 01986 } 01987 01988 ~Query() 01989 { 01990 if (m_bAllocated) 01991 { 01992 xnNodeQueryFree(m_pQuery); 01993 } 01994 } 01995 01999 inline const XnNodeQuery* GetUnderlyingObject() const { return m_pQuery; } 02000 inline XnNodeQuery* GetUnderlyingObject() { return m_pQuery; } 02001 02006 inline XnStatus SetVendor(const XnChar* strVendor) 02007 { 02008 return xnNodeQuerySetVendor(m_pQuery, strVendor); 02009 } 02010 02019 inline XnStatus SetName(const XnChar* strName) 02020 { 02021 return xnNodeQuerySetName(m_pQuery, strName); 02022 } 02023 02027 inline XnStatus SetMinVersion(const XnVersion& minVersion) 02028 { 02029 return xnNodeQuerySetMinVersion(m_pQuery, &minVersion); 02030 } 02031 02035 inline XnStatus SetMinVersion(const Version& minVersion) 02036 { 02037 return xnNodeQuerySetMinVersion(m_pQuery, minVersion.GetUnderlying()); 02038 } 02039 02043 inline XnStatus SetMaxVersion(const XnVersion& maxVersion) 02044 { 02045 return xnNodeQuerySetMaxVersion(m_pQuery, &maxVersion); 02046 } 02047 02051 inline XnStatus SetMaxVersion(const Version& maxVersion) 02052 { 02053 return xnNodeQuerySetMaxVersion(m_pQuery, maxVersion.GetUnderlying()); 02054 } 02055 02068 inline XnStatus AddSupportedCapability(const XnChar* strNeededCapability) 02069 { 02070 return xnNodeQueryAddSupportedCapability(m_pQuery, strNeededCapability); 02071 } 02072 02083 inline XnStatus AddSupportedMapOutputMode(const XnMapOutputMode& MapOutputMode) 02084 { 02085 return xnNodeQueryAddSupportedMapOutputMode(m_pQuery, &MapOutputMode); 02086 } 02087 02092 inline XnStatus SetSupportedMinUserPositions(const XnUInt32 nCount) 02093 { 02094 return xnNodeQuerySetSupportedMinUserPositions(m_pQuery, nCount); 02095 } 02096 02108 inline XnStatus SetExistingNodeOnly(XnBool bExistingNode) 02109 { 02110 return xnNodeQuerySetExistingNodeOnly(m_pQuery, bExistingNode); 02111 } 02112 02117 inline XnStatus AddNeededNode(const XnChar* strInstanceName) 02118 { 02119 return xnNodeQueryAddNeededNode(m_pQuery, strInstanceName); 02120 } 02121 02126 inline XnStatus SetCreationInfo(const XnChar* strCreationInfo) 02127 { 02128 return xnNodeQuerySetCreationInfo(m_pQuery, strCreationInfo); 02129 } 02130 02131 private: 02132 XnNodeQuery* m_pQuery; 02133 XnBool m_bAllocated; 02134 }; 02135 02136 //--------------------------------------------------------------------------- 02137 // Node Info List 02138 //--------------------------------------------------------------------------- 02139 02144 class NodeInfoList 02145 { 02146 public: 02150 class Iterator 02151 { 02152 public: 02153 friend class NodeInfoList; 02154 02167 XnBool operator==(const Iterator& other) const 02168 { 02169 return m_it.pCurrent == other.m_it.pCurrent; 02170 } 02171 02178 XnBool operator!=(const Iterator& other) const 02179 { 02180 return m_it.pCurrent != other.m_it.pCurrent; 02181 } 02182 02187 inline Iterator& operator++() 02188 { 02189 UpdateInternalObject(xnNodeInfoListGetNext(m_it)); 02190 return *this; 02191 } 02192 02197 inline Iterator operator++(int) 02198 { 02199 XnNodeInfoListIterator curr = m_it; 02200 UpdateInternalObject(xnNodeInfoListGetNext(m_it)); 02201 return Iterator(curr); 02202 } 02203 02207 inline Iterator& operator--() 02208 { 02209 UpdateInternalObject(xnNodeInfoListGetPrevious(m_it)); 02210 return *this; 02211 } 02212 02216 inline Iterator operator--(int) 02217 { 02218 XnNodeInfoListIterator curr = m_it; 02219 UpdateInternalObject(xnNodeInfoListGetPrevious(m_it)); 02220 return Iterator(curr); 02221 } 02222 02226 inline NodeInfo operator*() 02227 { 02228 return m_Info; 02229 } 02230 02231 private: 02232 inline Iterator(XnNodeInfoListIterator it) : m_Info(NULL) 02233 { 02234 UpdateInternalObject(it); 02235 } 02236 02237 inline void UpdateInternalObject(XnNodeInfoListIterator it) 02238 { 02239 m_it = it; 02240 if (xnNodeInfoListIteratorIsValid(it)) 02241 { 02242 XnNodeInfo* pInfo = xnNodeInfoListGetCurrent(it); 02243 m_Info = NodeInfo(pInfo); 02244 } 02245 else 02246 { 02247 m_Info = NodeInfo(NULL); 02248 } 02249 } 02250 02251 NodeInfo m_Info; 02252 XnNodeInfoListIterator m_it; 02253 }; 02254 02258 inline NodeInfoList() 02259 { 02260 xnNodeInfoListAllocate(&m_pList); 02261 m_bAllocated = TRUE; 02262 } 02263 02270 inline NodeInfoList(XnNodeInfoList* pList) : m_pList(pList), m_bAllocated(FALSE) {} 02271 02272 inline ~NodeInfoList() 02273 { 02274 FreeImpl(); 02275 } 02276 02280 inline XnNodeInfoList* GetUnderlyingObject() const { return m_pList; } 02281 02288 inline void ReplaceUnderlyingObject(XnNodeInfoList* pList) 02289 { 02290 FreeImpl(); 02291 m_pList = pList; 02292 m_bAllocated = TRUE; 02293 } 02294 02299 inline XnStatus Add(XnProductionNodeDescription& description, const XnChar* strCreationInfo, NodeInfoList* pNeededNodes) 02300 { 02301 XnNodeInfoList* pList = (pNeededNodes == NULL) ? NULL : pNeededNodes->GetUnderlyingObject(); 02302 return xnNodeInfoListAdd(m_pList, &description, strCreationInfo, pList); 02303 } 02304 02309 inline XnStatus AddEx(XnProductionNodeDescription& description, const XnChar* strCreationInfo, NodeInfoList* pNeededNodes, const void* pAdditionalData, XnFreeHandler pFreeHandler) 02310 { 02311 XnNodeInfoList* pList = (pNeededNodes == NULL) ? NULL : pNeededNodes->GetUnderlyingObject(); 02312 return xnNodeInfoListAddEx(m_pList, &description, strCreationInfo, pList, pAdditionalData, pFreeHandler); 02313 } 02314 02319 inline XnStatus AddNode(NodeInfo& info) 02320 { 02321 return xnNodeInfoListAddNode(m_pList, info); 02322 } 02323 02328 inline XnStatus AddNodeFromAnotherList(Iterator& it) 02329 { 02330 return xnNodeInfoListAddNodeFromList(m_pList, it.m_it); 02331 } 02332 02337 inline Iterator Begin() const 02338 { 02339 return Iterator(xnNodeInfoListGetFirst(m_pList)); 02340 } 02341 02346 inline Iterator End() const 02347 { 02348 XnNodeInfoListIterator it = { NULL }; 02349 return Iterator(it); 02350 } 02351 02356 inline Iterator RBegin() const 02357 { 02358 return Iterator(xnNodeInfoListGetLast(m_pList)); 02359 } 02360 02365 inline Iterator REnd() const 02366 { 02367 XnNodeInfoListIterator it = { NULL }; 02368 return Iterator(it); 02369 } 02370 02375 inline XnStatus Remove(Iterator& it) 02376 { 02377 return xnNodeInfoListRemove(m_pList, it.m_it); 02378 } 02379 02384 inline XnStatus Clear() 02385 { 02386 return xnNodeInfoListClear(m_pList); 02387 } 02388 02393 inline XnStatus Append(NodeInfoList& other) 02394 { 02395 return xnNodeInfoListAppend(m_pList, other.GetUnderlyingObject()); 02396 } 02397 02401 inline XnBool IsEmpty() 02402 { 02403 return xnNodeInfoListIsEmpty(m_pList); 02404 } 02405 02410 inline XnStatus FilterList(Context& context, Query& query); 02411 02412 private: 02413 inline void FreeImpl() 02414 { 02415 if (m_bAllocated) 02416 { 02417 xnNodeInfoListFree(m_pList); 02418 m_bAllocated = FALSE; 02419 m_pList = NULL; 02420 } 02421 } 02422 02423 XnNodeInfoList* m_pList; 02424 XnBool m_bAllocated; 02425 }; 02426 02427 //--------------------------------------------------------------------------- 02428 // Production Nodes Functionality 02429 //--------------------------------------------------------------------------- 02430 02435 class Capability : public NodeWrapper 02436 { 02437 public: 02443 Capability(XnNodeHandle hNode) : NodeWrapper(hNode) {} 02444 Capability(const NodeWrapper& node) : NodeWrapper(node) {} 02445 }; 02446 02480 class ErrorStateCapability : public Capability 02481 { 02482 public: 02488 ErrorStateCapability(XnNodeHandle hNode) : Capability(hNode) {} 02489 ErrorStateCapability(const NodeWrapper& node) : Capability(node) {} 02490 02494 inline XnStatus GetErrorState() const 02495 { 02496 return xnGetNodeErrorState(GetHandle()); 02497 } 02498 02508 inline XnStatus RegisterToErrorStateChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 02509 { 02510 return _RegisterToStateChange(xnRegisterToNodeErrorStateChange, GetHandle(), handler, pCookie, hCallback); 02511 } 02512 02520 inline void UnregisterFromErrorStateChange(XnCallbackHandle hCallback) 02521 { 02522 _UnregisterFromStateChange(xnUnregisterFromNodeErrorStateChange, GetHandle(), hCallback); 02523 } 02524 }; 02525 02531 class GeneralIntCapability : public Capability 02532 { 02533 public: 02540 GeneralIntCapability(XnNodeHandle hNode, const XnChar* strCap) : Capability(hNode), m_strCap(strCap) {} 02541 GeneralIntCapability(const NodeWrapper& node, const XnChar* strCap) : Capability(node), m_strCap(strCap) {} 02542 02547 inline void GetRange(XnInt32& nMin, XnInt32& nMax, XnInt32& nStep, XnInt32& nDefault, XnBool& bIsAutoSupported) const 02548 { 02549 xnGetGeneralIntRange(GetHandle(), m_strCap, &nMin, &nMax, &nStep, &nDefault, &bIsAutoSupported); 02550 } 02551 02556 inline XnInt32 Get() 02557 { 02558 XnInt32 nValue; 02559 xnGetGeneralIntValue(GetHandle(), m_strCap, &nValue); 02560 return nValue; 02561 } 02562 02567 inline XnStatus Set(XnInt32 nValue) 02568 { 02569 return xnSetGeneralIntValue(GetHandle(), m_strCap, nValue); 02570 } 02571 02581 XnStatus RegisterToValueChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback); 02582 02590 void UnregisterFromValueChange(XnCallbackHandle hCallback); 02591 02592 private: 02593 const XnChar* m_strCap; 02594 }; 02595 02631 class ProductionNode : public NodeWrapper 02632 { 02633 public: 02639 inline ProductionNode(XnNodeHandle hNode = NULL) : NodeWrapper(hNode) {} 02640 inline ProductionNode(const NodeWrapper& other) : NodeWrapper(other) {} 02641 02650 inline NodeInfo GetInfo() const { return NodeInfo(xnGetNodeInfo(GetHandle())); } 02651 02656 inline XnStatus AddNeededNode(ProductionNode& needed) 02657 { 02658 return xnAddNeededNode(GetHandle(), needed.GetHandle()); 02659 } 02660 02665 inline XnStatus RemoveNeededNode(ProductionNode& needed) 02666 { 02667 return xnRemoveNeededNode(GetHandle(), needed.GetHandle()); 02668 } 02669 02681 inline void GetContext(Context& context) const; 02682 02692 inline Context GetContext() const; 02693 02705 inline XnBool IsCapabilitySupported(const XnChar* strCapabilityName) const 02706 { 02707 return xnIsCapabilitySupported(GetHandle(), strCapabilityName); 02708 } 02709 02714 inline XnStatus SetIntProperty(const XnChar* strName, XnUInt64 nValue) 02715 { 02716 return xnSetIntProperty(GetHandle(), strName, nValue); 02717 } 02718 02723 inline XnStatus SetRealProperty(const XnChar* strName, XnDouble dValue) 02724 { 02725 return xnSetRealProperty(GetHandle(), strName, dValue); 02726 } 02727 02732 inline XnStatus SetStringProperty(const XnChar* strName, const XnChar* strValue) 02733 { 02734 return xnSetStringProperty(GetHandle(), strName, strValue); 02735 } 02736 02741 inline XnStatus SetGeneralProperty(const XnChar* strName, XnUInt32 nBufferSize, const void* pBuffer) 02742 { 02743 return xnSetGeneralProperty(GetHandle(), strName, nBufferSize, pBuffer); 02744 } 02745 02750 inline XnStatus GetIntProperty(const XnChar* strName, XnUInt64& nValue) const 02751 { 02752 return xnGetIntProperty(GetHandle(), strName, &nValue); 02753 } 02754 02759 inline XnStatus GetRealProperty(const XnChar* strName, XnDouble &dValue) const 02760 { 02761 return xnGetRealProperty(GetHandle(), strName, &dValue); 02762 } 02763 02768 inline XnStatus GetStringProperty(const XnChar* strName, XnChar* csValue, XnUInt32 nBufSize) const 02769 { 02770 return xnGetStringProperty(GetHandle(), strName, csValue, nBufSize); 02771 } 02772 02777 inline XnStatus GetGeneralProperty(const XnChar* strName, XnUInt32 nBufferSize, void* pBuffer) const 02778 { 02779 return xnGetGeneralProperty(GetHandle(), strName, nBufferSize, pBuffer); 02780 } 02781 02786 inline XnStatus LockForChanges(XnLockHandle* phLock) 02787 { 02788 return xnLockNodeForChanges(GetHandle(), phLock); 02789 } 02790 02795 inline void UnlockForChanges(XnLockHandle hLock) 02796 { 02797 xnUnlockNodeForChanges(GetHandle(), hLock); 02798 } 02799 02804 inline XnStatus LockedNodeStartChanges(XnLockHandle hLock) 02805 { 02806 return xnLockedNodeStartChanges(GetHandle(), hLock); 02807 } 02808 02813 inline void LockedNodeEndChanges(XnLockHandle hLock) 02814 { 02815 xnLockedNodeEndChanges(GetHandle(), hLock); 02816 } 02817 02826 inline const ErrorStateCapability GetErrorStateCap() const 02827 { 02828 return ErrorStateCapability(GetHandle()); 02829 } 02830 02839 inline ErrorStateCapability GetErrorStateCap() 02840 { 02841 return ErrorStateCapability(GetHandle()); 02842 } 02843 02855 inline GeneralIntCapability GetGeneralIntCap(const XnChar* strCapability) 02856 { 02857 return GeneralIntCapability(GetHandle(), strCapability); 02858 } 02859 }; 02860 02870 class DeviceIdentificationCapability : public Capability 02871 { 02872 public: 02878 DeviceIdentificationCapability(XnNodeHandle hNode) : Capability(hNode) {} 02879 DeviceIdentificationCapability(const NodeWrapper& node) : Capability(node) {} 02880 02890 inline XnStatus GetDeviceName(XnChar* strBuffer, XnUInt32 nBufferSize) 02891 { 02892 return xnGetDeviceName(GetHandle(), strBuffer, &nBufferSize); 02893 } 02894 02904 inline XnStatus GetVendorSpecificData(XnChar* strBuffer, XnUInt32 nBufferSize) 02905 { 02906 return xnGetVendorSpecificData(GetHandle(), strBuffer, &nBufferSize); 02907 } 02908 02918 inline XnStatus GetSerialNumber(XnChar* strBuffer, XnUInt32 nBufferSize) 02919 { 02920 return xnGetSerialNumber(GetHandle(), strBuffer, &nBufferSize); 02921 } 02922 }; 02923 02937 class Device : public ProductionNode 02938 { 02939 public: 02940 inline Device(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {} 02941 inline Device(const NodeWrapper& other) : ProductionNode(other) {} 02942 02951 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL); 02952 02966 inline DeviceIdentificationCapability GetIdentificationCap() 02967 { 02968 return DeviceIdentificationCapability(GetHandle()); 02969 } 02970 }; 02971 03019 class MirrorCapability : public Capability 03020 { 03021 public: 03022 inline MirrorCapability(XnNodeHandle hNode) : Capability(hNode) {} 03023 MirrorCapability(const NodeWrapper& node) : Capability(node) {} 03024 03031 inline XnStatus SetMirror(XnBool bMirror) 03032 { 03033 return xnSetMirror(GetHandle(), bMirror); 03034 } 03035 03039 inline XnBool IsMirrored() const 03040 { 03041 return xnIsMirrored(GetHandle()); 03042 } 03043 03053 inline XnStatus RegisterToMirrorChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 03054 { 03055 return _RegisterToStateChange(xnRegisterToMirrorChange, GetHandle(), handler, pCookie, hCallback); 03056 } 03057 03065 inline void UnregisterFromMirrorChange(XnCallbackHandle hCallback) 03066 { 03067 _UnregisterFromStateChange(xnUnregisterFromMirrorChange, GetHandle(), hCallback); 03068 } 03069 }; 03070 03103 class AlternativeViewPointCapability : public Capability 03104 { 03105 public: 03106 inline AlternativeViewPointCapability(XnNodeHandle hNode) : Capability(hNode) {} 03107 AlternativeViewPointCapability(const NodeWrapper& node) : Capability(node) {} 03108 03123 inline XnBool IsViewPointSupported(ProductionNode& otherNode) const 03124 { 03125 return xnIsViewPointSupported(GetHandle(), otherNode.GetHandle()); 03126 } 03127 03135 inline XnStatus SetViewPoint(ProductionNode& otherNode) 03136 { 03137 return xnSetViewPoint(GetHandle(), otherNode.GetHandle()); 03138 } 03139 03143 inline XnStatus ResetViewPoint() 03144 { 03145 return xnResetViewPoint(GetHandle()); 03146 } 03147 03155 inline XnBool IsViewPointAs(ProductionNode& otherNode) const 03156 { 03157 return xnIsViewPointAs(GetHandle(), otherNode.GetHandle()); 03158 } 03159 03169 inline XnStatus RegisterToViewPointChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 03170 { 03171 return _RegisterToStateChange(xnRegisterToViewPointChange, GetHandle(), handler, pCookie, hCallback); 03172 } 03173 03181 inline void UnregisterFromViewPointChange(XnCallbackHandle hCallback) 03182 { 03183 _UnregisterFromStateChange(xnUnregisterFromViewPointChange, GetHandle(), hCallback); 03184 } 03185 }; 03186 03208 class FrameSyncCapability : public Capability 03209 { 03210 public: 03211 inline FrameSyncCapability(XnNodeHandle hNode) : Capability(hNode) {} 03212 FrameSyncCapability(const NodeWrapper& node) : Capability(node) {} 03213 03222 inline XnBool CanFrameSyncWith(Generator& other) const; 03223 03230 inline XnStatus FrameSyncWith(Generator& other); 03231 03236 inline XnStatus StopFrameSyncWith(Generator& other); 03237 03244 inline XnBool IsFrameSyncedWith(Generator& other) const; 03245 03255 inline XnStatus RegisterToFrameSyncChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 03256 { 03257 return _RegisterToStateChange(xnRegisterToFrameSyncChange, GetHandle(), handler, pCookie, hCallback); 03258 } 03259 03267 inline void UnregisterFromFrameSyncChange(XnCallbackHandle hCallback) 03268 { 03269 _UnregisterFromStateChange(xnUnregisterFromFrameSyncChange, GetHandle(), hCallback); 03270 } 03271 }; 03272 03325 class Generator : public ProductionNode 03326 { 03327 public: 03333 inline Generator(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {} 03334 inline Generator(const NodeWrapper& other) : ProductionNode(other) {} 03335 03355 inline XnStatus StartGenerating() 03356 { 03357 return xnStartGenerating(GetHandle()); 03358 } 03359 03363 inline XnBool IsGenerating() const 03364 { 03365 return xnIsGenerating(GetHandle()); 03366 } 03367 03376 inline XnStatus StopGenerating() 03377 { 03378 return xnStopGenerating(GetHandle()); 03379 } 03380 03394 inline XnStatus RegisterToGenerationRunningChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle &hCallback) 03395 { 03396 return _RegisterToStateChange(xnRegisterToGenerationRunningChange, GetHandle(), handler, pCookie, hCallback); 03397 } 03398 03406 inline void UnregisterFromGenerationRunningChange(XnCallbackHandle hCallback) 03407 { 03408 _UnregisterFromStateChange(xnUnregisterFromGenerationRunningChange, GetHandle(), hCallback); 03409 } 03410 03424 inline XnStatus RegisterToNewDataAvailable(StateChangedHandler handler, void* pCookie, XnCallbackHandle &hCallback) 03425 { 03426 return _RegisterToStateChange(xnRegisterToNewDataAvailable, GetHandle(), handler, pCookie, hCallback); 03427 } 03428 03436 inline void UnregisterFromNewDataAvailable(XnCallbackHandle hCallback) 03437 { 03438 _UnregisterFromStateChange(xnUnregisterFromNewDataAvailable, GetHandle(), hCallback); 03439 } 03440 03449 inline XnBool IsNewDataAvailable(XnUInt64* pnTimestamp = NULL) const 03450 { 03451 return xnIsNewDataAvailable(GetHandle(), pnTimestamp); 03452 } 03453 03472 inline XnStatus WaitAndUpdateData() 03473 { 03474 return xnWaitAndUpdateData(GetHandle()); 03475 } 03476 03481 inline XnBool IsDataNew() const 03482 { 03483 return xnIsDataNew(GetHandle()); 03484 } 03485 03503 inline const void* GetData() 03504 { 03505 return xnGetData(GetHandle()); 03506 } 03507 03521 inline XnUInt32 GetDataSize() const 03522 { 03523 return xnGetDataSize(GetHandle()); 03524 } 03525 03539 inline XnUInt64 GetTimestamp() const 03540 { 03541 return xnGetTimestamp(GetHandle()); 03542 } 03543 03556 inline XnUInt32 GetFrameID() const 03557 { 03558 return xnGetFrameID(GetHandle()); 03559 } 03560 03569 inline const MirrorCapability GetMirrorCap() const 03570 { 03571 return MirrorCapability(GetHandle()); 03572 } 03573 03582 inline MirrorCapability GetMirrorCap() 03583 { 03584 return MirrorCapability(GetHandle()); 03585 } 03586 03597 inline const AlternativeViewPointCapability GetAlternativeViewPointCap() const 03598 { 03599 return AlternativeViewPointCapability(GetHandle()); 03600 } 03601 03612 inline AlternativeViewPointCapability GetAlternativeViewPointCap() 03613 { 03614 return AlternativeViewPointCapability(GetHandle()); 03615 } 03616 03626 inline const FrameSyncCapability GetFrameSyncCap() const 03627 { 03628 return FrameSyncCapability(GetHandle()); 03629 } 03630 03640 inline FrameSyncCapability GetFrameSyncCap() 03641 { 03642 return FrameSyncCapability(GetHandle()); 03643 } 03644 }; 03645 03690 class Recorder : public ProductionNode 03691 { 03692 public: 03698 inline Recorder(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {} 03699 inline Recorder(const NodeWrapper& other) : ProductionNode(other) {} 03700 03708 inline XnStatus Create(Context& context, const XnChar* strFormatName = NULL); 03709 03718 inline XnStatus SetDestination(XnRecordMedium destType, const XnChar* strDest) 03719 { 03720 return xnSetRecorderDestination(GetHandle(), destType, strDest); 03721 } 03722 03732 inline XnStatus GetDestination(XnRecordMedium& destType, XnChar* strDest, XnUInt32 nBufSize) 03733 { 03734 return xnGetRecorderDestination(GetHandle(), &destType, strDest, nBufSize); 03735 } 03736 03746 inline XnStatus AddNodeToRecording(ProductionNode& Node, XnCodecID compression = XN_CODEC_NULL) 03747 { 03748 return xnAddNodeToRecording(GetHandle(), Node.GetHandle(), compression); 03749 } 03750 03757 inline XnStatus RemoveNodeFromRecording(ProductionNode& Node) 03758 { 03759 return xnRemoveNodeFromRecording(GetHandle(), Node.GetHandle()); 03760 } 03761 03774 inline XnStatus Record() 03775 { 03776 return xnRecord(GetHandle()); 03777 } 03778 }; 03779 03807 class Player : public ProductionNode 03808 { 03809 public: 03815 inline Player(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {} 03816 inline Player(const NodeWrapper& other) : ProductionNode(other) {} 03817 03826 inline XnStatus Create(Context& context, const XnChar* strFormatName); 03827 03828 03843 inline XnStatus SetRepeat(XnBool bRepeat) 03844 { 03845 return xnSetPlayerRepeat(GetHandle(), bRepeat); 03846 } 03847 03852 inline XnStatus SetSource(XnRecordMedium sourceType, const XnChar* strSource) 03853 { 03854 return xnSetPlayerSource(GetHandle(), sourceType, strSource); 03855 } 03856 03865 inline XnStatus GetSource(XnRecordMedium &sourceType, XnChar* strSource, XnUInt32 nBufSize) const 03866 { 03867 return xnGetPlayerSource(GetHandle(), &sourceType, strSource, nBufSize); 03868 } 03869 03874 inline XnStatus ReadNext() 03875 { 03876 return xnPlayerReadNext(GetHandle()); 03877 } 03878 03903 inline XnStatus SeekToTimeStamp(XnInt64 nTimeOffset, XnPlayerSeekOrigin origin) 03904 { 03905 return xnSeekPlayerToTimeStamp(GetHandle(), nTimeOffset, origin); 03906 } 03907 03932 inline XnStatus SeekToFrame(const XnChar* strNodeName, XnInt32 nFrameOffset, XnPlayerSeekOrigin origin) 03933 { 03934 return xnSeekPlayerToFrame(GetHandle(), strNodeName, nFrameOffset, origin); 03935 } 03936 03942 inline XnStatus TellTimestamp(XnUInt64& nTimestamp) const 03943 { 03944 return xnTellPlayerTimestamp(GetHandle(), &nTimestamp); 03945 } 03946 03959 inline XnStatus TellFrame(const XnChar* strNodeName, XnUInt32& nFrame) const 03960 { 03961 return xnTellPlayerFrame(GetHandle(), strNodeName, &nFrame); 03962 } 03963 03971 inline XnStatus GetNumFrames(const XnChar* strNodeName, XnUInt32& nFrames) const 03972 { 03973 return xnGetPlayerNumFrames(GetHandle(), strNodeName, &nFrames); 03974 } 03975 03980 inline const XnChar* GetSupportedFormat() const 03981 { 03982 return xnGetPlayerSupportedFormat(GetHandle()); 03983 } 03984 03989 inline XnStatus EnumerateNodes(NodeInfoList& list) const 03990 { 03991 XnNodeInfoList* pList; 03992 XnStatus nRetVal = xnEnumeratePlayerNodes(GetHandle(), &pList); 03993 XN_IS_STATUS_OK(nRetVal); 03994 03995 list.ReplaceUnderlyingObject(pList); 03996 03997 return (XN_STATUS_OK); 03998 } 03999 04008 inline XnBool IsEOF() const 04009 { 04010 return xnIsPlayerAtEOF(GetHandle()); 04011 } 04012 04022 inline XnStatus RegisterToEndOfFileReached(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 04023 { 04024 return _RegisterToStateChange(xnRegisterToEndOfFileReached, GetHandle(), handler, pCookie, hCallback); 04025 } 04026 04034 inline void UnregisterFromEndOfFileReached(XnCallbackHandle hCallback) 04035 { 04036 _UnregisterFromStateChange(xnUnregisterFromEndOfFileReached, GetHandle(), hCallback); 04037 } 04038 04057 inline XnStatus SetPlaybackSpeed(XnDouble dSpeed) 04058 { 04059 return xnSetPlaybackSpeed(GetHandle(), dSpeed); 04060 } 04061 04066 inline XnDouble GetPlaybackSpeed() const 04067 { 04068 return xnGetPlaybackSpeed(GetHandle()); 04069 } 04070 }; 04071 04099 class CroppingCapability : public Capability 04100 { 04101 public: 04107 inline CroppingCapability(XnNodeHandle hNode) : Capability(hNode) {} 04108 CroppingCapability(const NodeWrapper& node) : Capability(node) {} 04109 04119 inline XnStatus SetCropping(const XnCropping& Cropping) 04120 { 04121 return xnSetCropping(GetHandle(), &Cropping); 04122 } 04123 04134 inline XnStatus GetCropping(XnCropping& Cropping) const 04135 { 04136 return xnGetCropping(GetHandle(), &Cropping); 04137 } 04138 04148 inline XnStatus RegisterToCroppingChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 04149 { 04150 return _RegisterToStateChange(xnRegisterToCroppingChange, GetHandle(), handler, pCookie, hCallback); 04151 } 04152 04160 inline void UnregisterFromCroppingChange(XnCallbackHandle hCallback) 04161 { 04162 _UnregisterFromStateChange(xnUnregisterFromCroppingChange, GetHandle(), hCallback); 04163 } 04164 }; 04165 04174 class AntiFlickerCapability : public Capability 04175 { 04176 public: 04182 inline AntiFlickerCapability(XnNodeHandle hNode) : Capability(hNode) {} 04183 AntiFlickerCapability(const NodeWrapper& node) : Capability(node) {} 04184 04189 inline XnStatus SetPowerLineFrequency(XnPowerLineFrequency nFrequency) 04190 { 04191 return xnSetPowerLineFrequency(GetHandle(), nFrequency); 04192 } 04193 04198 inline XnPowerLineFrequency GetPowerLineFrequency() 04199 { 04200 return xnGetPowerLineFrequency(GetHandle()); 04201 } 04202 04212 inline XnStatus RegisterToPowerLineFrequencyChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 04213 { 04214 return _RegisterToStateChange(xnRegisterToPowerLineFrequencyChange, GetHandle(), handler, pCookie, hCallback); 04215 } 04216 04224 inline void UnregisterFromPowerLineFrequencyChange(XnCallbackHandle hCallback) 04225 { 04226 _UnregisterFromStateChange(xnUnregisterFromPowerLineFrequencyChange, GetHandle(), hCallback); 04227 } 04228 }; 04229 04253 class MapGenerator : public Generator 04254 { 04255 public: 04261 inline MapGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {} 04262 inline MapGenerator(const NodeWrapper& other) : Generator(other) {} 04263 04271 inline XnUInt32 GetSupportedMapOutputModesCount() const 04272 { 04273 return xnGetSupportedMapOutputModesCount(GetHandle()); 04274 } 04275 04286 inline XnStatus GetSupportedMapOutputModes(XnMapOutputMode* aModes, XnUInt32& nCount) const 04287 { 04288 return xnGetSupportedMapOutputModes(GetHandle(), aModes, &nCount); 04289 } 04290 04304 inline XnStatus SetMapOutputMode(const XnMapOutputMode& OutputMode) 04305 { 04306 return xnSetMapOutputMode(GetHandle(), &OutputMode); 04307 } 04308 04326 inline XnStatus GetMapOutputMode(XnMapOutputMode &OutputMode) const 04327 { 04328 return xnGetMapOutputMode(GetHandle(), &OutputMode); 04329 } 04330 04339 inline XnUInt32 GetBytesPerPixel() const 04340 { 04341 return xnGetBytesPerPixel(GetHandle()); 04342 } 04343 04353 inline XnStatus RegisterToMapOutputModeChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 04354 { 04355 return _RegisterToStateChange(xnRegisterToMapOutputModeChange, GetHandle(), handler, pCookie, hCallback); 04356 } 04357 04365 inline void UnregisterFromMapOutputModeChange(XnCallbackHandle hCallback) 04366 { 04367 _UnregisterFromStateChange(xnUnregisterFromMapOutputModeChange, GetHandle(), hCallback); 04368 } 04369 04378 inline const CroppingCapability GetCroppingCap() const 04379 { 04380 return CroppingCapability(GetHandle()); 04381 } 04382 04391 inline CroppingCapability GetCroppingCap() 04392 { 04393 return CroppingCapability(GetHandle()); 04394 } 04395 04401 inline GeneralIntCapability GetBrightnessCap() 04402 { 04403 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_BRIGHTNESS); 04404 } 04405 04411 inline GeneralIntCapability GetContrastCap() 04412 { 04413 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_CONTRAST); 04414 } 04415 04421 inline GeneralIntCapability GetHueCap() 04422 { 04423 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_HUE); 04424 } 04425 04431 inline GeneralIntCapability GetSaturationCap() 04432 { 04433 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_SATURATION); 04434 } 04435 04441 inline GeneralIntCapability GetSharpnessCap() 04442 { 04443 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_SHARPNESS); 04444 } 04445 04451 inline GeneralIntCapability GetGammaCap() 04452 { 04453 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_GAMMA); 04454 } 04455 04461 inline GeneralIntCapability GetWhiteBalanceCap() 04462 { 04463 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_COLOR_TEMPERATURE); 04464 } 04465 04471 inline GeneralIntCapability GetBacklightCompensationCap() 04472 { 04473 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_BACKLIGHT_COMPENSATION); 04474 } 04475 04481 inline GeneralIntCapability GetGainCap() 04482 { 04483 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_GAIN); 04484 } 04485 04491 inline GeneralIntCapability GetPanCap() 04492 { 04493 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_PAN); 04494 } 04495 04501 inline GeneralIntCapability GetTiltCap() 04502 { 04503 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_TILT); 04504 } 04505 04511 inline GeneralIntCapability GetRollCap() 04512 { 04513 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_ROLL); 04514 } 04515 04521 inline GeneralIntCapability GetZoomCap() 04522 { 04523 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_ZOOM); 04524 } 04525 04531 inline GeneralIntCapability GetExposureCap() 04532 { 04533 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_EXPOSURE); 04534 } 04535 04541 inline GeneralIntCapability GetIrisCap() 04542 { 04543 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_IRIS); 04544 } 04545 04551 inline GeneralIntCapability GetFocusCap() 04552 { 04553 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_FOCUS); 04554 } 04555 04561 inline GeneralIntCapability GetLowLightCompensationCap() 04562 { 04563 return GeneralIntCapability(GetHandle(), XN_CAPABILITY_LOW_LIGHT_COMPENSATION); 04564 } 04565 04571 inline AntiFlickerCapability GetAntiFlickerCap() 04572 { 04573 return AntiFlickerCapability(GetHandle()); 04574 } 04575 }; 04576 04585 class UserPositionCapability : public Capability 04586 { 04587 public: 04593 inline UserPositionCapability(XnNodeHandle hNode = NULL) : Capability(hNode) {} 04594 UserPositionCapability(const NodeWrapper& node) : Capability(node) {} 04595 04600 inline XnUInt32 GetSupportedUserPositionsCount() const 04601 { 04602 return xnGetSupportedUserPositionsCount(GetHandle()); 04603 } 04604 04609 inline XnStatus SetUserPosition(XnUInt32 nIndex, const XnBoundingBox3D& Position) 04610 { 04611 return xnSetUserPosition(GetHandle(), nIndex, &Position); 04612 } 04613 04618 inline XnStatus GetUserPosition(XnUInt32 nIndex, XnBoundingBox3D& Position) const 04619 { 04620 return xnGetUserPosition(GetHandle(), nIndex, &Position); 04621 } 04622 04632 inline XnStatus RegisterToUserPositionChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 04633 { 04634 return _RegisterToStateChange(xnRegisterToUserPositionChange, GetHandle(), handler, pCookie, hCallback); 04635 } 04636 04644 inline void UnregisterFromUserPositionChange(XnCallbackHandle hCallback) 04645 { 04646 _UnregisterFromStateChange(xnUnregisterFromUserPositionChange, GetHandle(), hCallback); 04647 } 04648 }; 04649 04694 class DepthGenerator : public MapGenerator 04695 { 04696 public: 04702 inline DepthGenerator(XnNodeHandle hNode = NULL) : MapGenerator(hNode) {} 04703 inline DepthGenerator(const NodeWrapper& other) : MapGenerator(other) {} 04704 04712 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL); 04713 04730 inline void GetMetaData(DepthMetaData& metaData) const 04731 { 04732 xnGetDepthMetaData(GetHandle(), metaData.GetUnderlying()); 04733 } 04734 04739 inline const XnDepthPixel* GetDepthMap() const 04740 { 04741 return xnGetDepthMap(GetHandle()); 04742 } 04743 04753 inline XnDepthPixel GetDeviceMaxDepth() const 04754 { 04755 return xnGetDeviceMaxDepth(GetHandle()); 04756 } 04757 04776 inline XnStatus GetFieldOfView(XnFieldOfView& FOV) const 04777 { 04778 return xnGetDepthFieldOfView(GetHandle(), &FOV); 04779 } 04780 04790 inline XnStatus RegisterToFieldOfViewChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 04791 { 04792 return _RegisterToStateChange(xnRegisterToDepthFieldOfViewChange, GetHandle(), handler, pCookie, hCallback); 04793 } 04794 04802 inline void UnregisterFromFieldOfViewChange(XnCallbackHandle hCallback) 04803 { 04804 _UnregisterFromStateChange(xnUnregisterFromDepthFieldOfViewChange, GetHandle(), hCallback); 04805 } 04806 04816 inline XnStatus ConvertProjectiveToRealWorld(XnUInt32 nCount, const XnPoint3D aProjective[], XnPoint3D aRealWorld[]) const 04817 { 04818 return xnConvertProjectiveToRealWorld(GetHandle(), nCount, aProjective, aRealWorld); 04819 } 04820 04830 inline XnStatus ConvertRealWorldToProjective(XnUInt32 nCount, const XnPoint3D aRealWorld[], XnPoint3D aProjective[]) const 04831 { 04832 return xnConvertRealWorldToProjective(GetHandle(), nCount, aRealWorld, aProjective); 04833 } 04834 04840 inline const UserPositionCapability GetUserPositionCap() const 04841 { 04842 return UserPositionCapability(GetHandle()); 04843 } 04844 04850 inline UserPositionCapability GetUserPositionCap() 04851 { 04852 return UserPositionCapability(GetHandle()); 04853 } 04854 }; 04855 04860 class MockDepthGenerator : public DepthGenerator 04861 { 04862 public: 04868 inline MockDepthGenerator(XnNodeHandle hNode = NULL) : DepthGenerator(hNode) {} 04869 inline MockDepthGenerator(const NodeWrapper& other) : DepthGenerator(other) {} 04870 04877 XnStatus Create(Context& context, const XnChar* strName = NULL); 04878 04886 XnStatus CreateBasedOn(DepthGenerator& other, const XnChar* strName = NULL); 04887 04892 inline XnStatus SetData(XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize, const XnDepthPixel* pDepthMap) 04893 { 04894 return xnMockDepthSetData(GetHandle(), nFrameID, nTimestamp, nDataSize, pDepthMap); 04895 } 04896 04905 inline XnStatus SetData(const DepthMetaData& depthMD, XnUInt32 nFrameID, XnUInt64 nTimestamp) 04906 { 04907 return SetData(nFrameID, nTimestamp, depthMD.DataSize(), depthMD.Data()); 04908 } 04909 04915 inline XnStatus SetData(const DepthMetaData& depthMD) 04916 { 04917 return SetData(depthMD, depthMD.FrameID(), depthMD.Timestamp()); 04918 } 04919 }; 04920 04939 class ImageGenerator : public MapGenerator 04940 { 04941 public: 04947 inline ImageGenerator(XnNodeHandle hNode = NULL) : MapGenerator(hNode) {} 04948 inline ImageGenerator(const NodeWrapper& other) : MapGenerator(other) {} 04949 04955 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL); 04956 04973 inline void GetMetaData(ImageMetaData& metaData) const 04974 { 04975 xnGetImageMetaData(GetHandle(), metaData.GetUnderlying()); 04976 } 04977 04982 inline const XnRGB24Pixel* GetRGB24ImageMap() const 04983 { 04984 return xnGetRGB24ImageMap(GetHandle()); 04985 } 04986 04991 inline const XnYUV422DoublePixel* GetYUV422ImageMap() const 04992 { 04993 return xnGetYUV422ImageMap(GetHandle()); 04994 } 04995 05000 inline const XnGrayscale8Pixel* GetGrayscale8ImageMap() const 05001 { 05002 return xnGetGrayscale8ImageMap(GetHandle()); 05003 } 05004 05009 inline const XnGrayscale16Pixel* GetGrayscale16ImageMap() const 05010 { 05011 return xnGetGrayscale16ImageMap(GetHandle()); 05012 } 05013 05018 inline const XnUInt8* GetImageMap() const 05019 { 05020 return xnGetImageMap(GetHandle()); 05021 } 05022 05033 inline XnBool IsPixelFormatSupported(XnPixelFormat Format) const 05034 { 05035 return xnIsPixelFormatSupported(GetHandle(), Format); 05036 } 05037 05055 inline XnStatus SetPixelFormat(XnPixelFormat Format) 05056 { 05057 return xnSetPixelFormat(GetHandle(), Format); 05058 } 05059 05070 inline XnPixelFormat GetPixelFormat() const 05071 { 05072 return xnGetPixelFormat(GetHandle()); 05073 } 05074 05084 inline XnStatus RegisterToPixelFormatChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 05085 { 05086 return _RegisterToStateChange(xnRegisterToPixelFormatChange, GetHandle(), handler, pCookie, hCallback); 05087 } 05088 05096 inline void UnregisterFromPixelFormatChange(XnCallbackHandle hCallback) 05097 { 05098 _UnregisterFromStateChange(xnUnregisterFromPixelFormatChange, GetHandle(), hCallback); 05099 } 05100 }; 05101 05106 class MockImageGenerator : public ImageGenerator 05107 { 05108 public: 05114 inline MockImageGenerator(XnNodeHandle hNode = NULL) : ImageGenerator(hNode) {} 05115 inline MockImageGenerator(const NodeWrapper& other) : ImageGenerator(other) {} 05116 05123 XnStatus Create(Context& context, const XnChar* strName = NULL); 05124 05132 XnStatus CreateBasedOn(ImageGenerator& other, const XnChar* strName = NULL); 05133 05138 inline XnStatus SetData(XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize, const XnUInt8* pImageMap) 05139 { 05140 return xnMockImageSetData(GetHandle(), nFrameID, nTimestamp, nDataSize, pImageMap); 05141 } 05142 05151 inline XnStatus SetData(const ImageMetaData& imageMD, XnUInt32 nFrameID, XnUInt64 nTimestamp) 05152 { 05153 return SetData(nFrameID, nTimestamp, imageMD.DataSize(), imageMD.Data()); 05154 } 05155 05161 inline XnStatus SetData(const ImageMetaData& imageMD) 05162 { 05163 return SetData(imageMD, imageMD.FrameID(), imageMD.Timestamp()); 05164 } 05165 }; 05166 05175 class IRGenerator : public MapGenerator 05176 { 05177 public: 05183 inline IRGenerator(XnNodeHandle hNode = NULL) : MapGenerator(hNode) {} 05184 inline IRGenerator(const NodeWrapper& other) : MapGenerator(other) {} 05185 05192 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL); 05193 05210 inline void GetMetaData(IRMetaData& metaData) const 05211 { 05212 xnGetIRMetaData(GetHandle(), metaData.GetUnderlying()); 05213 } 05214 05218 inline const XnIRPixel* GetIRMap() const 05219 { 05220 return xnGetIRMap(GetHandle()); 05221 } 05222 }; 05223 05228 class MockIRGenerator : public IRGenerator 05229 { 05230 public: 05236 inline MockIRGenerator(XnNodeHandle hNode = NULL) : IRGenerator(hNode) {} 05237 inline MockIRGenerator(const NodeWrapper& other) : IRGenerator(other) {} 05238 05245 XnStatus Create(Context& context, const XnChar* strName = NULL); 05252 XnStatus CreateBasedOn(IRGenerator& other, const XnChar* strName = NULL); 05253 05258 inline XnStatus SetData(XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize, const XnIRPixel* pIRMap) 05259 { 05260 return xnMockIRSetData(GetHandle(), nFrameID, nTimestamp, nDataSize, pIRMap); 05261 } 05262 05271 inline XnStatus SetData(const IRMetaData& irMD, XnUInt32 nFrameID, XnUInt64 nTimestamp) 05272 { 05273 return SetData(nFrameID, nTimestamp, irMD.DataSize(), irMD.Data()); 05274 } 05275 05281 inline XnStatus SetData(const IRMetaData& irMD) 05282 { 05283 return SetData(irMD, irMD.FrameID(), irMD.Timestamp()); 05284 } 05285 }; 05286 05354 class GestureGenerator : public Generator 05355 { 05356 public: 05362 inline GestureGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {} 05363 inline GestureGenerator(const NodeWrapper& other) : Generator(other) {} 05364 05378 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL); 05379 05393 inline XnStatus AddGesture(const XnChar* strGesture, XnBoundingBox3D* pArea) 05394 { 05395 return xnAddGesture(GetHandle(), strGesture, pArea); 05396 } 05397 05405 inline XnStatus RemoveGesture(const XnChar* strGesture) 05406 { 05407 return xnRemoveGesture(GetHandle(), strGesture); 05408 } 05409 05418 inline XnStatus GetAllActiveGestures(XnChar** astrGestures, XnUInt32 nNameLength, XnUInt16& nGestures) const 05419 { 05420 return xnGetAllActiveGestures(GetHandle(), astrGestures, nNameLength, &nGestures); 05421 } 05422 05427 inline XnUInt16 GetNumberOfAvailableGestures() const 05428 { 05429 return xnGetNumberOfAvailableGestures(GetHandle()); 05430 } 05431 05440 inline XnStatus EnumerateAllGestures(XnChar** astrGestures, XnUInt32 nNameLength, XnUInt16& nGestures) const 05441 { 05442 return xnEnumerateAllGestures(GetHandle(), astrGestures, nNameLength, &nGestures); 05443 } 05444 05450 inline XnBool IsGestureAvailable(const XnChar* strGesture) const 05451 { 05452 return xnIsGestureAvailable(GetHandle(), strGesture); 05453 } 05454 05459 inline XnBool IsGestureProgressSupported(const XnChar* strGesture) const 05460 { 05461 return xnIsGestureProgressSupported(GetHandle(), strGesture); 05462 } 05463 05485 typedef void (XN_CALLBACK_TYPE* GestureRecognized)(GestureGenerator& generator, const XnChar* strGesture, const XnPoint3D* pIDPosition, const XnPoint3D* pEndPosition, void* pCookie); 05486 05513 typedef void (XN_CALLBACK_TYPE* GestureProgress)(GestureGenerator& generator, const XnChar* strGesture, const XnPoint3D* pPosition, XnFloat fProgress, void* pCookie); 05514 05526 XnStatus RegisterGestureCallbacks(GestureRecognized RecognizedCB, GestureProgress ProgressCB, void* pCookie, XnCallbackHandle& hCallback) 05527 { 05528 XnStatus nRetVal = XN_STATUS_OK; 05529 05530 GestureCookie* pGestureCookie; 05531 XN_VALIDATE_ALLOC(pGestureCookie, GestureCookie); 05532 pGestureCookie->recognizedHandler = RecognizedCB; 05533 pGestureCookie->progressHandler = ProgressCB; 05534 pGestureCookie->pUserCookie = pCookie; 05535 05536 nRetVal = xnRegisterGestureCallbacks(GetHandle(), GestureRecognizedCallback, GestureProgressCallback, pGestureCookie, &pGestureCookie->hCallback); 05537 if (nRetVal != XN_STATUS_OK) 05538 { 05539 xnOSFree(pGestureCookie); 05540 return (nRetVal); 05541 } 05542 05543 hCallback = pGestureCookie; 05544 05545 return (XN_STATUS_OK); 05546 } 05547 05555 inline void UnregisterGestureCallbacks(XnCallbackHandle hCallback) 05556 { 05557 GestureCookie* pGestureCookie = (GestureCookie*)hCallback; 05558 xnUnregisterGestureCallbacks(GetHandle(), pGestureCookie->hCallback); 05559 xnOSFree(pGestureCookie); 05560 } 05561 05571 inline XnStatus RegisterToGestureChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 05572 { 05573 return _RegisterToStateChange(xnRegisterToGestureChange, GetHandle(), handler, pCookie, hCallback); 05574 } 05575 05583 inline void UnregisterFromGestureChange(XnCallbackHandle hCallback) 05584 { 05585 _UnregisterFromStateChange(xnUnregisterFromGestureChange, GetHandle(), hCallback); 05586 } 05587 05615 typedef void (XN_CALLBACK_TYPE* GestureIntermediateStageCompleted)(GestureGenerator& generator, const XnChar* strGesture, const XnPoint3D* pPosition, void* pCookie); 05616 05626 XnStatus RegisterToGestureIntermediateStageCompleted(GestureIntermediateStageCompleted handler, void* pCookie, XnCallbackHandle& hCallback) 05627 { 05628 XnStatus nRetVal = XN_STATUS_OK; 05629 05630 GestureIntermediateStageCompletedCookie* pGestureCookie; 05631 XN_VALIDATE_ALLOC(pGestureCookie, GestureIntermediateStageCompletedCookie); 05632 pGestureCookie->handler = handler; 05633 pGestureCookie->pUserCookie = pCookie; 05634 05635 nRetVal = xnRegisterToGestureIntermediateStageCompleted(GetHandle(), GestureIntermediateStageCompletedCallback, pGestureCookie, &pGestureCookie->hCallback); 05636 if (nRetVal != XN_STATUS_OK) 05637 { 05638 xnOSFree(pGestureCookie); 05639 return (nRetVal); 05640 } 05641 05642 hCallback = pGestureCookie; 05643 05644 return (XN_STATUS_OK); 05645 } 05646 05654 inline void UnregisterFromGestureIntermediateStageCompleted(XnCallbackHandle hCallback) 05655 { 05656 GestureIntermediateStageCompletedCookie* pGestureCookie = (GestureIntermediateStageCompletedCookie*)hCallback; 05657 xnUnregisterFromGestureIntermediateStageCompleted(GetHandle(), pGestureCookie->hCallback); 05658 xnOSFree(pGestureCookie); 05659 } 05660 05679 typedef void (XN_CALLBACK_TYPE* GestureReadyForNextIntermediateStage)(GestureGenerator& generator, const XnChar* strGesture, const XnPoint3D* pPosition, void* pCookie); 05680 05690 XnStatus RegisterToGestureReadyForNextIntermediateStage(GestureReadyForNextIntermediateStage handler, void* pCookie, XnCallbackHandle& hCallback) 05691 { 05692 XnStatus nRetVal = XN_STATUS_OK; 05693 05694 GestureReadyForNextIntermediateStageCookie* pGestureCookie; 05695 XN_VALIDATE_ALLOC(pGestureCookie, GestureReadyForNextIntermediateStageCookie); 05696 pGestureCookie->handler = handler; 05697 pGestureCookie->pUserCookie = pCookie; 05698 05699 nRetVal = xnRegisterToGestureReadyForNextIntermediateStage(GetHandle(), GestureReadyForNextIntermediateStageCallback, pGestureCookie, &pGestureCookie->hCallback); 05700 if (nRetVal != XN_STATUS_OK) 05701 { 05702 xnOSFree(pGestureCookie); 05703 return (nRetVal); 05704 } 05705 05706 hCallback = pGestureCookie; 05707 05708 return (XN_STATUS_OK); 05709 } 05710 05718 inline void UnregisterFromGestureReadyForNextIntermediateStageCallbacks(XnCallbackHandle hCallback) 05719 { 05720 GestureReadyForNextIntermediateStageCookie* pGestureCookie = (GestureReadyForNextIntermediateStageCookie*)hCallback; 05721 xnUnregisterFromGestureReadyForNextIntermediateStage(GetHandle(), pGestureCookie->hCallback); 05722 xnOSFree(pGestureCookie); 05723 } 05724 05726 inline XnStatus XN_API_DEPRECATED("Use GetAllActiveGestures() instead") GetActiveGestures(XnChar*& astrGestures, XnUInt16& nGestures) const 05727 { 05728 return xnGetActiveGestures(GetHandle(), &astrGestures, &nGestures); 05729 } 05730 inline XnStatus XN_API_DEPRECATED("Use EnumerateAllGestures() instead") EnumerateGestures(XnChar*& astrGestures, XnUInt16& nGestures) const 05731 { 05732 return xnEnumerateGestures(GetHandle(), &astrGestures, &nGestures); 05733 } 05736 private: 05737 typedef struct GestureCookie 05738 { 05739 GestureRecognized recognizedHandler; 05740 GestureProgress progressHandler; 05741 void* pUserCookie; 05742 XnCallbackHandle hCallback; 05743 } GestureCookie; 05744 05745 static void XN_CALLBACK_TYPE GestureRecognizedCallback(XnNodeHandle hNode, const XnChar* strGesture, const XnPoint3D* pIDPosition, const XnPoint3D* pEndPosition, void* pCookie) 05746 { 05747 GestureCookie* pGestureCookie = (GestureCookie*)pCookie; 05748 GestureGenerator gen(hNode); 05749 if (pGestureCookie->recognizedHandler != NULL) 05750 { 05751 pGestureCookie->recognizedHandler(gen, strGesture, pIDPosition, pEndPosition, pGestureCookie->pUserCookie); 05752 } 05753 } 05754 05755 static void XN_CALLBACK_TYPE GestureProgressCallback(XnNodeHandle hNode, const XnChar* strGesture, const XnPoint3D* pPosition, XnFloat fProgress, void* pCookie) 05756 { 05757 GestureCookie* pGestureCookie = (GestureCookie*)pCookie; 05758 GestureGenerator gen(hNode); 05759 if (pGestureCookie->progressHandler != NULL) 05760 { 05761 pGestureCookie->progressHandler(gen, strGesture, pPosition, fProgress, pGestureCookie->pUserCookie); 05762 } 05763 } 05764 05765 typedef struct GestureIntermediateStageCompletedCookie 05766 { 05767 GestureIntermediateStageCompleted handler; 05768 void* pUserCookie; 05769 XnCallbackHandle hCallback; 05770 } GestureIntermediateStageCompletedCookie; 05771 05772 static void XN_CALLBACK_TYPE GestureIntermediateStageCompletedCallback(XnNodeHandle hNode, const XnChar* strGesture, const XnPoint3D* pPosition, void* pCookie) 05773 { 05774 GestureIntermediateStageCompletedCookie* pGestureCookie = (GestureIntermediateStageCompletedCookie*)pCookie; 05775 GestureGenerator gen(hNode); 05776 if (pGestureCookie->handler != NULL) 05777 { 05778 pGestureCookie->handler(gen, strGesture, pPosition, pGestureCookie->pUserCookie); 05779 } 05780 } 05781 05782 typedef struct GestureReadyForNextIntermediateStageCookie 05783 { 05784 GestureReadyForNextIntermediateStage handler; 05785 void* pUserCookie; 05786 XnCallbackHandle hCallback; 05787 } GestureReadyForNextIntermediateStageCookie; 05788 05789 static void XN_CALLBACK_TYPE GestureReadyForNextIntermediateStageCallback(XnNodeHandle hNode, const XnChar* strGesture, const XnPoint3D* pPosition, void* pCookie) 05790 { 05791 GestureReadyForNextIntermediateStageCookie* pGestureCookie = (GestureReadyForNextIntermediateStageCookie*)pCookie; 05792 GestureGenerator gen(hNode); 05793 if (pGestureCookie->handler != NULL) 05794 { 05795 pGestureCookie->handler(gen, strGesture, pPosition, pGestureCookie->pUserCookie); 05796 } 05797 } 05798 }; 05799 05818 class SceneAnalyzer : public MapGenerator 05819 { 05820 public: 05826 inline SceneAnalyzer(XnNodeHandle hNode = NULL) : MapGenerator(hNode) {} 05827 inline SceneAnalyzer(const NodeWrapper& other) : MapGenerator(other) {} 05828 05836 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL); 05837 05838 05858 inline void GetMetaData(SceneMetaData& metaData) const 05859 { 05860 xnGetSceneMetaData(GetHandle(), metaData.GetUnderlying()); 05861 } 05862 05867 inline const XnLabel* GetLabelMap() const 05868 { 05869 return xnGetLabelMap(GetHandle()); 05870 } 05871 05877 inline XnStatus GetFloor(XnPlane3D& Plane) const 05878 { 05879 return xnGetFloor(GetHandle(), &Plane); 05880 } 05881 }; 05882 05890 class HandTouchingFOVEdgeCapability : public Capability 05891 { 05892 public: 05898 inline HandTouchingFOVEdgeCapability(XnNodeHandle hNode) : Capability(hNode) {} 05899 HandTouchingFOVEdgeCapability(const NodeWrapper& node) : Capability(node) {} 05900 05911 typedef void (XN_CALLBACK_TYPE* HandTouchingFOVEdge)(HandTouchingFOVEdgeCapability& touchingfov, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, XnDirection eDir, void* pCookie); 05912 05922 inline XnStatus RegisterToHandTouchingFOVEdge(HandTouchingFOVEdge handler, void* pCookie, XnCallbackHandle& hCallback) 05923 { 05924 XnStatus nRetVal = XN_STATUS_OK; 05925 05926 HandTouchingFOVEdgeCookie* pHandCookie; 05927 XN_VALIDATE_ALLOC(pHandCookie, HandTouchingFOVEdgeCookie); 05928 pHandCookie->handler = handler; 05929 pHandCookie->pUserCookie = pCookie; 05930 05931 nRetVal = xnRegisterToHandTouchingFOVEdge(GetHandle(), HandTouchingFOVEdgeCB, pHandCookie, &pHandCookie->hCallback); 05932 if (nRetVal != XN_STATUS_OK) 05933 { 05934 xnOSFree(pHandCookie); 05935 return (nRetVal); 05936 } 05937 05938 hCallback = pHandCookie; 05939 05940 return (XN_STATUS_OK); 05941 } 05942 05950 inline void UnregisterFromHandTouchingFOVEdge(XnCallbackHandle hCallback) 05951 { 05952 HandTouchingFOVEdgeCookie* pHandCookie = (HandTouchingFOVEdgeCookie*)hCallback; 05953 xnUnregisterFromHandTouchingFOVEdge(GetHandle(), pHandCookie->hCallback); 05954 xnOSFree(pHandCookie); 05955 } 05956 private: 05957 typedef struct HandTouchingFOVEdgeCookie 05958 { 05959 HandTouchingFOVEdge handler; 05960 void* pUserCookie; 05961 XnCallbackHandle hCallback; 05962 } HandTouchingFOVEdgeCookie; 05963 05964 static void XN_CALLBACK_TYPE HandTouchingFOVEdgeCB(XnNodeHandle hNode, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, XnDirection eDir, void* pCookie) 05965 { 05966 HandTouchingFOVEdgeCookie* pHandCookie = (HandTouchingFOVEdgeCookie*)pCookie; 05967 HandTouchingFOVEdgeCapability cap(hNode); 05968 if (pHandCookie->handler != NULL) 05969 { 05970 pHandCookie->handler(cap, user, pPosition, fTime, eDir, pHandCookie->pUserCookie); 05971 } 05972 } 05973 05974 }; 05975 06063 class HandsGenerator : public Generator 06064 { 06065 public: 06071 inline HandsGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {} 06072 inline HandsGenerator(const NodeWrapper& other) : Generator(other) {} 06073 06081 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL); 06082 06098 typedef void (XN_CALLBACK_TYPE* HandCreate)(HandsGenerator& generator, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, void* pCookie); 06099 06116 typedef void (XN_CALLBACK_TYPE* HandUpdate)(HandsGenerator& generator, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, void* pCookie); 06117 06131 typedef void (XN_CALLBACK_TYPE* HandDestroy)(HandsGenerator& generator, XnUserID user, XnFloat fTime, void* pCookie); 06132 06145 inline XnStatus RegisterHandCallbacks(HandCreate CreateCB, HandUpdate UpdateCB, HandDestroy DestroyCB, void* pCookie, XnCallbackHandle& hCallback) 06146 { 06147 XnStatus nRetVal = XN_STATUS_OK; 06148 06149 HandCookie* pHandCookie; 06150 XN_VALIDATE_ALLOC(pHandCookie, HandCookie); 06151 pHandCookie->createHandler = CreateCB; 06152 pHandCookie->updateHandler = UpdateCB; 06153 pHandCookie->destroyHandler = DestroyCB; 06154 pHandCookie->pUserCookie = pCookie; 06155 06156 nRetVal = xnRegisterHandCallbacks(GetHandle(), HandCreateCB, HandUpdateCB, HandDestroyCB, pHandCookie, &pHandCookie->hCallback); 06157 if (nRetVal != XN_STATUS_OK) 06158 { 06159 xnOSFree(pHandCookie); 06160 return (nRetVal); 06161 } 06162 06163 hCallback = pHandCookie; 06164 06165 return (XN_STATUS_OK); 06166 } 06167 06175 inline void UnregisterHandCallbacks(XnCallbackHandle hCallback) 06176 { 06177 HandCookie* pHandCookie = (HandCookie*)hCallback; 06178 xnUnregisterHandCallbacks(GetHandle(), pHandCookie->hCallback); 06179 xnOSFree(pHandCookie); 06180 } 06181 06195 inline XnStatus StopTracking(XnUserID user) 06196 { 06197 return xnStopTracking(GetHandle(), user); 06198 } 06199 06208 inline XnStatus StopTrackingAll() 06209 { 06210 return xnStopTrackingAll(GetHandle()); 06211 } 06212 06229 inline XnStatus StartTracking(const XnPoint3D& ptPosition) 06230 { 06231 return xnStartTracking(GetHandle(), &ptPosition); 06232 } 06233 06250 inline XnStatus SetSmoothing(XnFloat fSmoothingFactor) 06251 { 06252 return xnSetTrackingSmoothing(GetHandle(), fSmoothingFactor); 06253 } 06254 06262 inline const HandTouchingFOVEdgeCapability GetHandTouchingFOVEdgeCap() const 06263 { 06264 return HandTouchingFOVEdgeCapability(GetHandle()); 06265 } 06266 06274 inline HandTouchingFOVEdgeCapability GetHandTouchingFOVEdgeCap() 06275 { 06276 return HandTouchingFOVEdgeCapability(GetHandle()); 06277 } 06278 06279 private: 06280 typedef struct HandCookie 06281 { 06282 HandCreate createHandler; 06283 HandUpdate updateHandler; 06284 HandDestroy destroyHandler; 06285 void* pUserCookie; 06286 XnCallbackHandle hCallback; 06287 } HandCookie; 06288 06289 static void XN_CALLBACK_TYPE HandCreateCB(XnNodeHandle hNode, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, void* pCookie) 06290 { 06291 HandCookie* pHandCookie = (HandCookie*)pCookie; 06292 HandsGenerator gen(hNode); 06293 if (pHandCookie->createHandler != NULL) 06294 { 06295 pHandCookie->createHandler(gen, user, pPosition, fTime, pHandCookie->pUserCookie); 06296 } 06297 } 06298 static void XN_CALLBACK_TYPE HandUpdateCB(XnNodeHandle hNode, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, void* pCookie) 06299 { 06300 HandCookie* pHandCookie = (HandCookie*)pCookie; 06301 HandsGenerator gen(hNode); 06302 if (pHandCookie->updateHandler != NULL) 06303 { 06304 pHandCookie->updateHandler(gen, user, pPosition, fTime, pHandCookie->pUserCookie); 06305 } 06306 } 06307 static void XN_CALLBACK_TYPE HandDestroyCB(XnNodeHandle hNode, XnUserID user, XnFloat fTime, void* pCookie) 06308 { 06309 HandCookie* pHandCookie = (HandCookie*)pCookie; 06310 HandsGenerator gen(hNode); 06311 if (pHandCookie->destroyHandler != NULL) 06312 { 06313 pHandCookie->destroyHandler(gen, user, fTime, pHandCookie->pUserCookie); 06314 } 06315 } 06316 }; 06317 06374 class SkeletonCapability : public Capability 06375 { 06376 public: 06382 inline SkeletonCapability(XnNodeHandle hNode) : Capability(hNode) {} 06383 SkeletonCapability(const NodeWrapper& node) : Capability(node) {} 06384 06390 inline XnBool IsJointAvailable(XnSkeletonJoint eJoint) const 06391 { 06392 return xnIsJointAvailable(GetHandle(), eJoint); 06393 } 06394 06400 inline XnBool IsProfileAvailable(XnSkeletonProfile eProfile) const 06401 { 06402 return xnIsProfileAvailable(GetHandle(), eProfile); 06403 } 06404 06435 inline XnStatus SetSkeletonProfile(XnSkeletonProfile eProfile) 06436 { 06437 return xnSetSkeletonProfile(GetHandle(), eProfile); 06438 } 06439 06463 inline XnStatus SetJointActive(XnSkeletonJoint eJoint, XnBool bState) 06464 { 06465 return xnSetJointActive(GetHandle(), eJoint, bState); 06466 } 06467 06473 inline XnBool IsJointActive(XnSkeletonJoint eJoint) const 06474 { 06475 return xnIsJointActive(GetHandle(), eJoint); 06476 } 06477 06487 inline XnStatus RegisterToJointConfigurationChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 06488 { 06489 return _RegisterToStateChange(xnRegisterToJointConfigurationChange, GetHandle(), handler, pCookie, hCallback); 06490 } 06491 06499 inline void UnregisterFromJointConfigurationChange(XnCallbackHandle hCallback) 06500 { 06501 _UnregisterFromStateChange(xnUnregisterFromJointConfigurationChange, GetHandle(), hCallback); 06502 } 06503 06508 inline XnStatus EnumerateActiveJoints(XnSkeletonJoint* pJoints, XnUInt16& nJoints) const 06509 { 06510 return xnEnumerateActiveJoints(GetHandle(), pJoints, &nJoints); 06511 } 06512 06521 inline XnStatus GetSkeletonJoint(XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointTransformation& Joint) const 06522 { 06523 return xnGetSkeletonJoint(GetHandle(), user, eJoint, &Joint); 06524 } 06525 06547 inline XnStatus GetSkeletonJointPosition(XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointPosition& Joint) const 06548 { 06549 return xnGetSkeletonJointPosition(GetHandle(), user, eJoint, &Joint); 06550 } 06551 06559 inline XnStatus GetSkeletonJointOrientation(XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointOrientation& Joint) const 06560 { 06561 return xnGetSkeletonJointOrientation(GetHandle(), user, eJoint, &Joint); 06562 } 06563 06574 inline XnBool IsTracking(XnUserID user) const 06575 { 06576 return xnIsSkeletonTracking(GetHandle(), user); 06577 } 06578 06589 inline XnBool IsCalibrated(XnUserID user) const 06590 { 06591 return xnIsSkeletonCalibrated(GetHandle(), user); 06592 } 06593 06604 inline XnBool IsCalibrating(XnUserID user) const 06605 { 06606 return xnIsSkeletonCalibrating(GetHandle(), user); 06607 } 06608 06633 inline XnStatus RequestCalibration(XnUserID user, XnBool bForce) 06634 { 06635 return xnRequestSkeletonCalibration(GetHandle(), user, bForce); 06636 } 06637 06647 inline XnStatus AbortCalibration(XnUserID user) 06648 { 06649 return xnAbortSkeletonCalibration(GetHandle(), user); 06650 } 06651 06670 inline XnStatus SaveCalibrationDataToFile(XnUserID user, const XnChar* strFileName) 06671 { 06672 return xnSaveSkeletonCalibrationDataToFile(GetHandle(), user, strFileName); 06673 } 06674 06681 inline XnStatus LoadCalibrationDataFromFile(XnUserID user, const XnChar* strFileName) 06682 { 06683 return xnLoadSkeletonCalibrationDataFromFile(GetHandle(), user, strFileName); 06684 } 06685 06697 inline XnStatus SaveCalibrationData(XnUserID user, XnUInt32 nSlot) 06698 { 06699 return xnSaveSkeletonCalibrationData(GetHandle(), user, nSlot); 06700 } 06701 06708 inline XnStatus LoadCalibrationData(XnUserID user, XnUInt32 nSlot) 06709 { 06710 return xnLoadSkeletonCalibrationData(GetHandle(), user, nSlot); 06711 } 06712 06718 inline XnStatus ClearCalibrationData(XnUInt32 nSlot) 06719 { 06720 return xnClearSkeletonCalibrationData(GetHandle(), nSlot); 06721 } 06722 06728 inline XnBool IsCalibrationData(XnUInt32 nSlot) const 06729 { 06730 return xnIsSkeletonCalibrationData(GetHandle(), nSlot); 06731 } 06732 06747 inline XnStatus StartTracking(XnUserID user) 06748 { 06749 return xnStartSkeletonTracking(GetHandle(), user); 06750 } 06751 06756 inline XnStatus StopTracking(XnUserID user) 06757 { 06758 return xnStopSkeletonTracking(GetHandle(), user); 06759 } 06760 06769 inline XnStatus Reset(XnUserID user) 06770 { 06771 return xnResetSkeleton(GetHandle(), user); 06772 } 06773 06782 inline XnBool NeedPoseForCalibration() const 06783 { 06784 return xnNeedPoseForSkeletonCalibration(GetHandle()); 06785 } 06786 06799 inline XnStatus GetCalibrationPose(XnChar* strPose) const 06800 { 06801 return xnGetSkeletonCalibrationPose(GetHandle(), strPose); 06802 } 06803 06816 inline XnStatus SetSmoothing(XnFloat fSmoothingFactor) 06817 { 06818 return xnSetSkeletonSmoothing(GetHandle(), fSmoothingFactor); 06819 } 06820 06842 typedef void (XN_CALLBACK_TYPE* CalibrationStart)(SkeletonCapability& skeleton, XnUserID user, void* pCookie); 06843 06861 typedef void (XN_CALLBACK_TYPE* CalibrationEnd)(SkeletonCapability& skeleton, XnUserID user, XnBool bSuccess, void* pCookie); 06862 06874 inline XnStatus RegisterToCalibrationStart(CalibrationStart handler, void* pCookie, XnCallbackHandle& hCallback) 06875 { 06876 XnStatus nRetVal = XN_STATUS_OK; 06877 CalibrationStartCookie* pCalibrationCookie; 06878 XN_VALIDATE_ALLOC(pCalibrationCookie, CalibrationStartCookie); 06879 pCalibrationCookie->handler = handler; 06880 pCalibrationCookie->pUserCookie = pCookie; 06881 nRetVal = xnRegisterToCalibrationStart(GetHandle(), CalibrationStartCallback, pCalibrationCookie, &pCalibrationCookie->hCallback); 06882 if (nRetVal != XN_STATUS_OK) 06883 { 06884 xnOSFree(pCalibrationCookie); 06885 return nRetVal; 06886 } 06887 hCallback = pCalibrationCookie; 06888 return XN_STATUS_OK; 06889 } 06890 06901 inline XnStatus UnregisterFromCalibrationStart(XnCallbackHandle hCallback) 06902 { 06903 CalibrationStartCookie* pCalibrationCookie = (CalibrationStartCookie*)hCallback; 06904 xnUnregisterFromCalibrationStart(GetHandle(), pCalibrationCookie->hCallback); 06905 xnOSFree(pCalibrationCookie); 06906 return XN_STATUS_OK; 06907 } 06908 06930 typedef void (XN_CALLBACK_TYPE* CalibrationInProgress)(SkeletonCapability& skeleton, XnUserID user, XnCalibrationStatus calibrationError, void* pCookie); 06931 06941 inline XnStatus RegisterToCalibrationInProgress(CalibrationInProgress handler, void* pCookie, XnCallbackHandle& hCallback) 06942 { 06943 XnStatus nRetVal = XN_STATUS_OK; 06944 06945 CalibrationInProgressCookie* pSkeletonCookie; 06946 XN_VALIDATE_ALLOC(pSkeletonCookie, CalibrationInProgressCookie); 06947 pSkeletonCookie->handler = handler; 06948 pSkeletonCookie->pUserCookie = pCookie; 06949 06950 nRetVal = xnRegisterToCalibrationInProgress(GetHandle(), CalibrationInProgressCallback, pSkeletonCookie, &pSkeletonCookie->hCallback); 06951 if (nRetVal != XN_STATUS_OK) 06952 { 06953 xnOSFree(pSkeletonCookie); 06954 return (nRetVal); 06955 } 06956 06957 hCallback = pSkeletonCookie; 06958 06959 return (XN_STATUS_OK); 06960 } 06961 06969 inline void UnregisterFromCalibrationInProgress(XnCallbackHandle hCallback) 06970 { 06971 CalibrationInProgressCookie* pSkeletonCookie = (CalibrationInProgressCookie*)hCallback; 06972 xnUnregisterFromCalibrationInProgress(GetHandle(), pSkeletonCookie->hCallback); 06973 xnOSFree(pSkeletonCookie); 06974 } 06975 06993 typedef void (XN_CALLBACK_TYPE* CalibrationComplete)(SkeletonCapability& skeleton, XnUserID user, XnCalibrationStatus calibrationError, void* pCookie); 06994 07004 inline XnStatus RegisterToCalibrationComplete(CalibrationComplete handler, void* pCookie, XnCallbackHandle& hCallback) 07005 { 07006 XnStatus nRetVal = XN_STATUS_OK; 07007 07008 CalibrationCompleteCookie* pSkeletonCookie; 07009 XN_VALIDATE_ALLOC(pSkeletonCookie, CalibrationCompleteCookie); 07010 pSkeletonCookie->handler = handler; 07011 pSkeletonCookie->pUserCookie = pCookie; 07012 07013 nRetVal = xnRegisterToCalibrationComplete(GetHandle(), CalibrationCompleteCallback, pSkeletonCookie, &pSkeletonCookie->hCallback); 07014 if (nRetVal != XN_STATUS_OK) 07015 { 07016 xnOSFree(pSkeletonCookie); 07017 return (nRetVal); 07018 } 07019 07020 hCallback = pSkeletonCookie; 07021 07022 return (XN_STATUS_OK); 07023 } 07024 07032 inline void UnregisterFromCalibrationComplete(XnCallbackHandle hCallback) 07033 { 07034 CalibrationCompleteCookie* pSkeletonCookie = (CalibrationCompleteCookie*)hCallback; 07035 xnUnregisterFromCalibrationComplete(GetHandle(), pSkeletonCookie->hCallback); 07036 xnOSFree(pSkeletonCookie); 07037 } 07038 07040 XN_API_DEPRECATED("Use the overload with one argument - the bState parameter is useless") 07041 inline XnBool IsJointActive(XnSkeletonJoint eJoint, XnBool /*bState*/) const 07042 { 07043 return xnIsJointActive(GetHandle(), eJoint); 07044 } 07045 07046 inline XnStatus XN_API_DEPRECATED("Please use RegisterToCalibrationStart/Complete") RegisterCalibrationCallbacks(CalibrationStart CalibrationStartCB, CalibrationEnd CalibrationEndCB, void* pCookie, XnCallbackHandle& hCallback) 07047 { 07048 XnStatus nRetVal = XN_STATUS_OK; 07049 07050 SkeletonCookie* pSkeletonCookie; 07051 XN_VALIDATE_ALLOC(pSkeletonCookie, SkeletonCookie); 07052 pSkeletonCookie->startHandler = CalibrationStartCB; 07053 pSkeletonCookie->endHandler = CalibrationEndCB; 07054 pSkeletonCookie->pUserCookie = pCookie; 07055 07056 #pragma warning (push) 07057 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS) 07058 nRetVal = xnRegisterCalibrationCallbacks(GetHandle(), CalibrationStartBundleCallback, CalibrationEndBundleCallback, pSkeletonCookie, &pSkeletonCookie->hCallback); 07059 #pragma warning (pop) 07060 if (nRetVal != XN_STATUS_OK) 07061 { 07062 xnOSFree(pSkeletonCookie); 07063 return (nRetVal); 07064 } 07065 07066 hCallback = pSkeletonCookie; 07067 07068 return (XN_STATUS_OK); 07069 } 07070 07071 inline void XN_API_DEPRECATED("Please use UnregisterFromCalibrationStart/Complete") UnregisterCalibrationCallbacks(XnCallbackHandle hCallback) 07072 { 07073 SkeletonCookie* pSkeletonCookie = (SkeletonCookie*)hCallback; 07074 #pragma warning (push) 07075 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS) 07076 xnUnregisterCalibrationCallbacks(GetHandle(), pSkeletonCookie->hCallback); 07077 #pragma warning (pop) 07078 xnOSFree(pSkeletonCookie); 07079 } 07082 private: 07083 typedef struct SkeletonCookie 07084 { 07085 CalibrationStart startHandler; 07086 CalibrationEnd endHandler; 07087 void* pUserCookie; 07088 XnCallbackHandle hCallback; 07089 } SkeletonCookie; 07090 07091 static void XN_CALLBACK_TYPE CalibrationStartBundleCallback(XnNodeHandle hNode, XnUserID user, void* pCookie) 07092 { 07093 SkeletonCookie* pSkeletonCookie = (SkeletonCookie*)pCookie; 07094 SkeletonCapability cap(hNode); 07095 if (pSkeletonCookie->startHandler != NULL) 07096 { 07097 pSkeletonCookie->startHandler(cap, user, pSkeletonCookie->pUserCookie); 07098 } 07099 } 07100 07101 static void XN_CALLBACK_TYPE CalibrationEndBundleCallback(XnNodeHandle hNode, XnUserID user, XnBool bSuccess, void* pCookie) 07102 { 07103 SkeletonCookie* pSkeletonCookie = (SkeletonCookie*)pCookie; 07104 SkeletonCapability cap(hNode); 07105 if (pSkeletonCookie->endHandler != NULL) 07106 { 07107 pSkeletonCookie->endHandler(cap, user, bSuccess, pSkeletonCookie->pUserCookie); 07108 } 07109 } 07110 07111 typedef struct CalibrationStartCookie 07112 { 07113 CalibrationStart handler; 07114 void* pUserCookie; 07115 XnCallbackHandle hCallback; 07116 } CalibrationStartCookie; 07117 07118 static void XN_CALLBACK_TYPE CalibrationStartCallback(XnNodeHandle hNode, XnUserID user, void* pCookie) 07119 { 07120 CalibrationStartCookie* pCalibrationCookie = (CalibrationStartCookie*)pCookie; 07121 SkeletonCapability cap(hNode); 07122 if (pCalibrationCookie->handler != NULL) 07123 { 07124 pCalibrationCookie->handler(cap, user, pCalibrationCookie->pUserCookie); 07125 } 07126 } 07127 07128 typedef struct CalibrationInProgressCookie 07129 { 07130 CalibrationInProgress handler; 07131 void* pUserCookie; 07132 XnCallbackHandle hCallback; 07133 } CalibrationInProgressCookie; 07134 07135 static void XN_CALLBACK_TYPE CalibrationInProgressCallback(XnNodeHandle hNode, XnUserID user, XnCalibrationStatus calibrationError, void* pCookie) 07136 { 07137 CalibrationInProgressCookie* pSkeletonCookie = (CalibrationInProgressCookie*)pCookie; 07138 SkeletonCapability cap(hNode); 07139 if (pSkeletonCookie->handler != NULL) 07140 { 07141 pSkeletonCookie->handler(cap, user, calibrationError, pSkeletonCookie->pUserCookie); 07142 } 07143 } 07144 07145 typedef struct CalibrationCompleteCookie 07146 { 07147 CalibrationComplete handler; 07148 void* pUserCookie; 07149 XnCallbackHandle hCallback; 07150 } CalibrationCompleteCookie; 07151 07152 static void XN_CALLBACK_TYPE CalibrationCompleteCallback(XnNodeHandle hNode, XnUserID user, XnCalibrationStatus calibrationError, void* pCookie) 07153 { 07154 CalibrationCompleteCookie* pSkeletonCookie = (CalibrationCompleteCookie*)pCookie; 07155 SkeletonCapability cap(hNode); 07156 if (pSkeletonCookie->handler != NULL) 07157 { 07158 pSkeletonCookie->handler(cap, user, calibrationError, pSkeletonCookie->pUserCookie); 07159 } 07160 } 07161 }; 07162 07184 class PoseDetectionCapability : public Capability 07185 { 07186 public: 07192 inline PoseDetectionCapability(XnNodeHandle hNode) : Capability(hNode) {} 07193 PoseDetectionCapability(const NodeWrapper& node) : Capability(node) {} 07194 07208 typedef void (XN_CALLBACK_TYPE* PoseDetection)(PoseDetectionCapability& pose, const XnChar* strPose, XnUserID user, void* pCookie); 07209 07219 inline XnUInt32 GetNumberOfPoses() const 07220 { 07221 return xnGetNumberOfPoses(GetHandle()); 07222 } 07223 07236 inline XnStatus GetAllAvailablePoses(XnChar** pstrPoses, XnUInt32 nNameLength, XnUInt32& nPoses) const 07237 { 07238 return xnGetAllAvailablePoses(GetHandle(), pstrPoses, nNameLength, &nPoses); 07239 } 07240 07241 inline XnBool IsPoseSupported(const XnChar* strPose) 07242 { 07243 return xnIsPoseSupported(GetHandle(), strPose); 07244 } 07245 07246 inline XnStatus GetPoseStatus(XnUserID userID, const XnChar* poseName, XnUInt64& poseTime, XnPoseDetectionStatus& eStatus, XnPoseDetectionState& eState) 07247 { 07248 return xnGetPoseStatus(GetHandle(), userID, poseName, &poseTime, &eStatus, &eState); 07249 } 07250 07266 inline XnStatus StartPoseDetection(const XnChar* strPose, XnUserID user) 07267 { 07268 return xnStartPoseDetection(GetHandle(), strPose, user); 07269 } 07270 07282 inline XnStatus StopPoseDetection(XnUserID user) 07283 { 07284 return xnStopPoseDetection(GetHandle(), user); 07285 } 07286 07290 inline XnStatus StopSinglePoseDetection(XnUserID user, const XnChar* strPose) 07291 { 07292 return xnStopSinglePoseDetection(GetHandle(), user, strPose); 07293 } 07294 07304 inline XnStatus RegisterToPoseDetected(PoseDetection handler, void* pCookie, XnCallbackHandle& hCallback) 07305 { 07306 XnStatus nRetVal = XN_STATUS_OK; 07307 PoseDetectionCookie* pPoseCookie; 07308 XN_VALIDATE_ALLOC(pPoseCookie, PoseDetectionCookie); 07309 pPoseCookie->handler = handler; 07310 pPoseCookie->pPoseCookie = pCookie; 07311 07312 nRetVal = xnRegisterToPoseDetected(GetHandle(), PoseDetectionCallback, pPoseCookie, &pPoseCookie->hCallback); 07313 if (nRetVal != XN_STATUS_OK) 07314 { 07315 xnOSFree(pPoseCookie); 07316 return nRetVal; 07317 } 07318 hCallback = pPoseCookie; 07319 return XN_STATUS_OK; 07320 } 07321 07331 inline XnStatus RegisterToOutOfPose(PoseDetection handler, void* pCookie, XnCallbackHandle& hCallback) 07332 { 07333 XnStatus nRetVal = XN_STATUS_OK; 07334 PoseDetectionCookie* pPoseCookie; 07335 XN_VALIDATE_ALLOC(pPoseCookie, PoseDetectionCookie); 07336 pPoseCookie->handler = handler; 07337 pPoseCookie->pPoseCookie = pCookie; 07338 07339 nRetVal = xnRegisterToOutOfPose(GetHandle(), PoseDetectionCallback, pPoseCookie, &pPoseCookie->hCallback); 07340 if (nRetVal != XN_STATUS_OK) 07341 { 07342 xnOSFree(pPoseCookie); 07343 return nRetVal; 07344 } 07345 hCallback = pPoseCookie; 07346 return XN_STATUS_OK; 07347 } 07355 inline void UnregisterFromPoseDetected(XnCallbackHandle hCallback) 07356 { 07357 PoseDetectionCookie* pPoseCookie = (PoseDetectionCookie*)hCallback; 07358 xnUnregisterFromPoseDetected(GetHandle(), pPoseCookie->hCallback); 07359 xnOSFree(pPoseCookie); 07360 } 07368 inline void UnregisterFromOutOfPose(XnCallbackHandle hCallback) 07369 { 07370 PoseDetectionCookie* pPoseCookie = (PoseDetectionCookie*)hCallback; 07371 xnUnregisterFromOutOfPose(GetHandle(), pPoseCookie->hCallback); 07372 xnOSFree(pPoseCookie); 07373 } 07374 07397 typedef void (XN_CALLBACK_TYPE* PoseInProgress)(PoseDetectionCapability& pose, const XnChar* strPose, XnUserID user, XnPoseDetectionStatus poseError, void* pCookie); 07398 07415 inline XnStatus RegisterToPoseInProgress(PoseInProgress handler, void* pCookie, XnCallbackHandle& hCallback) 07416 { 07417 XnStatus nRetVal = XN_STATUS_OK; 07418 07419 PoseInProgressCookie* pPoseCookie; 07420 XN_VALIDATE_ALLOC(pPoseCookie, PoseInProgressCookie); 07421 pPoseCookie->handler = handler; 07422 pPoseCookie->pPoseCookie = pCookie; 07423 07424 nRetVal = xnRegisterToPoseDetectionInProgress(GetHandle(), PoseDetectionInProgressCallback, pPoseCookie, &pPoseCookie->hCallback); 07425 if (nRetVal != XN_STATUS_OK) 07426 { 07427 xnOSFree(pPoseCookie); 07428 return (nRetVal); 07429 } 07430 07431 hCallback = pPoseCookie; 07432 07433 return (XN_STATUS_OK); 07434 } 07435 07443 inline void UnregisterFromPoseInProgress(XnCallbackHandle hCallback) 07444 { 07445 PoseInProgressCookie* pPoseCookie = (PoseInProgressCookie*)hCallback; 07446 xnUnregisterFromPoseDetectionInProgress(GetHandle(), pPoseCookie->hCallback); 07447 xnOSFree(pPoseCookie); 07448 } 07449 07451 inline XnStatus XN_API_DEPRECATED("Use GetAllAvailablePoses() instead") GetAvailablePoses(XnChar** pstrPoses, XnUInt32& nPoses) const 07452 { 07453 return xnGetAvailablePoses(GetHandle(), pstrPoses, &nPoses); 07454 } 07455 07456 inline XnStatus XN_API_DEPRECATED("Please use RegisterToPoseDetected/RegisterToOutOfPose instead") RegisterToPoseCallbacks(PoseDetection PoseStartCB, PoseDetection PoseEndCB, void* pCookie, XnCallbackHandle& hCallback) 07457 { 07458 XnStatus nRetVal = XN_STATUS_OK; 07459 07460 PoseCookie* pPoseCookie; 07461 XN_VALIDATE_ALLOC(pPoseCookie, PoseCookie); 07462 pPoseCookie->startHandler = PoseStartCB; 07463 pPoseCookie->endHandler = PoseEndCB; 07464 pPoseCookie->pPoseCookie = pCookie; 07465 07466 #pragma warning (push) 07467 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS) 07468 nRetVal = xnRegisterToPoseCallbacks(GetHandle(), PoseDetectionStartBundleCallback, PoseDetectionStartEndBundleCallback, pPoseCookie, &pPoseCookie->hCallback); 07469 #pragma warning (pop) 07470 if (nRetVal != XN_STATUS_OK) 07471 { 07472 xnOSFree(pPoseCookie); 07473 return (nRetVal); 07474 } 07475 07476 hCallback = pPoseCookie; 07477 07478 return (XN_STATUS_OK); 07479 } 07480 07481 inline void XN_API_DEPRECATED("Please use UnregisterFromPoseDetected/UnregisterFromOutOfPose instead") UnregisterFromPoseCallbacks(XnCallbackHandle hCallback) 07482 { 07483 PoseCookie* pPoseCookie = (PoseCookie*)hCallback; 07484 #pragma warning (push) 07485 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS) 07486 xnUnregisterFromPoseCallbacks(GetHandle(), pPoseCookie->hCallback); 07487 #pragma warning (pop) 07488 xnOSFree(pPoseCookie); 07489 } 07492 private: 07493 typedef struct PoseCookie 07494 { 07495 PoseDetection startHandler; 07496 PoseDetection endHandler; 07497 void* pPoseCookie; 07498 XnCallbackHandle hCallback; 07499 } PoseCookie; 07500 07501 static void XN_CALLBACK_TYPE PoseDetectionStartBundleCallback(XnNodeHandle hNode, const XnChar* strPose, XnUserID user, void* pCookie) 07502 { 07503 PoseCookie* pPoseCookie = (PoseCookie*)pCookie; 07504 PoseDetectionCapability cap(hNode); 07505 if (pPoseCookie->startHandler != NULL) 07506 { 07507 pPoseCookie->startHandler(cap, strPose, user, pPoseCookie->pPoseCookie); 07508 } 07509 } 07510 07511 static void XN_CALLBACK_TYPE PoseDetectionStartEndBundleCallback(XnNodeHandle hNode, const XnChar* strPose, XnUserID user, void* pCookie) 07512 { 07513 PoseCookie* pPoseCookie = (PoseCookie*)pCookie; 07514 PoseDetectionCapability cap(hNode); 07515 if (pPoseCookie->endHandler != NULL) 07516 { 07517 pPoseCookie->endHandler(cap, strPose, user, pPoseCookie->pPoseCookie); 07518 } 07519 } 07520 typedef struct PoseDetectionCookie 07521 { 07522 PoseDetection handler; 07523 void* pPoseCookie; 07524 XnCallbackHandle hCallback; 07525 } PoseDetectionCookie; 07526 static void XN_CALLBACK_TYPE PoseDetectionCallback(XnNodeHandle hNode, const XnChar* strPose, XnUserID user, void* pCookie) 07527 { 07528 PoseDetectionCookie* pPoseDetectionCookie = (PoseDetectionCookie*)pCookie; 07529 PoseDetectionCapability cap(hNode); 07530 if (pPoseDetectionCookie->handler != NULL) 07531 { 07532 pPoseDetectionCookie->handler(cap, strPose, user, pPoseDetectionCookie->pPoseCookie); 07533 } 07534 } 07535 07536 typedef struct PoseInProgressCookie 07537 { 07538 PoseInProgress handler; 07539 void* pPoseCookie; 07540 XnCallbackHandle hCallback; 07541 } PoseInProgressCookie; 07542 07543 static void XN_CALLBACK_TYPE PoseDetectionInProgressCallback(XnNodeHandle hNode, const XnChar* strPose, XnUserID user, XnPoseDetectionStatus poseErrors, void* pCookie) 07544 { 07545 PoseInProgressCookie* pPoseCookie = (PoseInProgressCookie*)pCookie; 07546 PoseDetectionCapability cap(hNode); 07547 if (pPoseCookie->handler != NULL) 07548 { 07549 pPoseCookie->handler(cap, strPose, user, poseErrors, pPoseCookie->pPoseCookie); 07550 } 07551 } 07552 }; 07553 07665 class UserGenerator : public Generator 07666 { 07667 public: 07673 inline UserGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {} 07674 inline UserGenerator(const NodeWrapper& other) : Generator(other) {} 07675 07683 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL); 07684 07697 typedef void (XN_CALLBACK_TYPE* UserHandler)(UserGenerator& generator, XnUserID user, void* pCookie); 07698 07706 inline XnUInt16 GetNumberOfUsers() const 07707 { 07708 return xnGetNumberOfUsers(GetHandle()); 07709 } 07710 07733 inline XnStatus GetUsers(XnUserID aUsers[], XnUInt16& nUsers) const 07734 { 07735 return xnGetUsers(GetHandle(), aUsers, &nUsers); 07736 } 07737 07757 inline XnStatus GetCoM(XnUserID user, XnPoint3D& com) const 07758 { 07759 return xnGetUserCoM(GetHandle(), user, &com); 07760 } 07761 07777 inline XnStatus GetUserPixels(XnUserID user, SceneMetaData& smd) const 07778 { 07779 return xnGetUserPixels(GetHandle(), user, smd.GetUnderlying()); 07780 } 07781 07792 inline XnStatus RegisterUserCallbacks(UserHandler NewUserCB, UserHandler LostUserCB, void* pCookie, XnCallbackHandle& hCallback) 07793 { 07794 XnStatus nRetVal = XN_STATUS_OK; 07795 07796 UserCookie* pUserCookie; 07797 XN_VALIDATE_ALLOC(pUserCookie, UserCookie); 07798 pUserCookie->newHandler = NewUserCB; 07799 pUserCookie->lostHandler = LostUserCB; 07800 pUserCookie->pUserCookie = pCookie; 07801 07802 nRetVal = xnRegisterUserCallbacks(GetHandle(), NewUserCallback, LostUserCallback, pUserCookie, &pUserCookie->hCallback); 07803 if (nRetVal != XN_STATUS_OK) 07804 { 07805 xnOSFree(pUserCookie); 07806 return (nRetVal); 07807 } 07808 07809 hCallback = pUserCookie; 07810 07811 return (XN_STATUS_OK); 07812 } 07813 07821 inline void UnregisterUserCallbacks(XnCallbackHandle hCallback) 07822 { 07823 UserCookie* pUserCookie = (UserCookie*)hCallback; 07824 xnUnregisterUserCallbacks(GetHandle(), pUserCookie->hCallback); 07825 xnOSFree(pUserCookie); 07826 } 07827 07839 inline const SkeletonCapability GetSkeletonCap() const 07840 { 07841 return SkeletonCapability(GetHandle()); 07842 } 07843 07855 inline SkeletonCapability GetSkeletonCap() 07856 { 07857 return SkeletonCapability(GetHandle()); 07858 } 07859 07870 inline const PoseDetectionCapability GetPoseDetectionCap() const 07871 { 07872 return PoseDetectionCapability(GetHandle()); 07873 } 07874 07885 inline PoseDetectionCapability GetPoseDetectionCap() 07886 { 07887 return PoseDetectionCapability(GetHandle()); 07888 } 07889 07899 inline XnStatus RegisterToUserExit(UserHandler handler, void* pCookie, XnCallbackHandle& hCallback) 07900 { 07901 XnStatus nRetVal = XN_STATUS_OK; 07902 07903 UserSingleCookie* pUserCookie; 07904 XN_VALIDATE_ALLOC(pUserCookie, UserSingleCookie); 07905 pUserCookie->handler = handler; 07906 pUserCookie->pUserCookie = pCookie; 07907 07908 nRetVal = xnRegisterToUserExit(GetHandle(), UserSingleCallback, pUserCookie, &pUserCookie->hCallback); 07909 if (nRetVal != XN_STATUS_OK) 07910 { 07911 xnOSFree(pUserCookie); 07912 return (nRetVal); 07913 } 07914 07915 hCallback = pUserCookie; 07916 07917 return (XN_STATUS_OK); 07918 } 07919 07927 inline void UnregisterFromUserExit(XnCallbackHandle hCallback) 07928 { 07929 UserSingleCookie* pUserCookie = (UserSingleCookie*)hCallback; 07930 xnUnregisterFromUserExit(GetHandle(), pUserCookie->hCallback); 07931 xnOSFree(pUserCookie); 07932 } 07933 07943 inline XnStatus RegisterToUserReEnter(UserHandler handler, void* pCookie, XnCallbackHandle& hCallback) 07944 { 07945 XnStatus nRetVal = XN_STATUS_OK; 07946 07947 UserSingleCookie* pUserCookie; 07948 XN_VALIDATE_ALLOC(pUserCookie, UserSingleCookie); 07949 pUserCookie->handler = handler; 07950 pUserCookie->pUserCookie = pCookie; 07951 07952 nRetVal = xnRegisterToUserReEnter(GetHandle(), UserSingleCallback, pUserCookie, &pUserCookie->hCallback); 07953 if (nRetVal != XN_STATUS_OK) 07954 { 07955 xnOSFree(pUserCookie); 07956 return (nRetVal); 07957 } 07958 07959 hCallback = pUserCookie; 07960 07961 return (XN_STATUS_OK); 07962 } 07963 07971 inline void UnregisterFromUserReEnter(XnCallbackHandle hCallback) 07972 { 07973 UserSingleCookie* pUserCookie = (UserSingleCookie*)hCallback; 07974 xnUnregisterFromUserReEnter(GetHandle(), pUserCookie->hCallback); 07975 xnOSFree(pUserCookie); 07976 } 07977 07978 private: 07979 typedef struct UserCookie 07980 { 07981 UserHandler newHandler; 07982 UserHandler lostHandler; 07983 void* pUserCookie; 07984 XnCallbackHandle hCallback; 07985 } UserCookie; 07986 07987 static void XN_CALLBACK_TYPE NewUserCallback(XnNodeHandle hNode, XnUserID user, void* pCookie) 07988 { 07989 UserCookie* pUserCookie = (UserCookie*)pCookie; 07990 UserGenerator gen(hNode); 07991 if (pUserCookie->newHandler != NULL) 07992 { 07993 pUserCookie->newHandler(gen, user, pUserCookie->pUserCookie); 07994 } 07995 } 07996 07997 static void XN_CALLBACK_TYPE LostUserCallback(XnNodeHandle hNode, XnUserID user, void* pCookie) 07998 { 07999 UserCookie* pUserCookie = (UserCookie*)pCookie; 08000 UserGenerator gen(hNode); 08001 if (pUserCookie->lostHandler != NULL) 08002 { 08003 pUserCookie->lostHandler(gen, user, pUserCookie->pUserCookie); 08004 } 08005 } 08006 08007 typedef struct UserSingleCookie 08008 { 08009 UserHandler handler; 08010 void* pUserCookie; 08011 XnCallbackHandle hCallback; 08012 } UserSingleCookie; 08013 08014 static void XN_CALLBACK_TYPE UserSingleCallback(XnNodeHandle hNode, XnUserID user, void* pCookie) 08015 { 08016 UserSingleCookie* pUserCookie = (UserSingleCookie*)pCookie; 08017 UserGenerator gen(hNode); 08018 if (pUserCookie->handler != NULL) 08019 { 08020 pUserCookie->handler(gen, user, pUserCookie->pUserCookie); 08021 } 08022 } 08023 }; 08024 08038 class AudioGenerator : public Generator 08039 { 08040 public: 08046 inline AudioGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {} 08047 inline AudioGenerator(const NodeWrapper& other) : Generator(other) {} 08048 08056 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL); 08057 08074 inline void GetMetaData(AudioMetaData& metaData) const 08075 { 08076 xnGetAudioMetaData(GetHandle(), metaData.GetUnderlying()); 08077 } 08078 08083 inline const XnUChar* GetAudioBuffer() const 08084 { 08085 return xnGetAudioBuffer(GetHandle()); 08086 } 08087 08091 inline XnUInt32 GetSupportedWaveOutputModesCount() const 08092 { 08093 return xnGetSupportedWaveOutputModesCount(GetHandle()); 08094 } 08095 08102 inline XnStatus GetSupportedWaveOutputModes(XnWaveOutputMode* aSupportedModes, XnUInt32& nCount) const 08103 { 08104 return xnGetSupportedWaveOutputModes(GetHandle(), aSupportedModes, &nCount); 08105 } 08106 08118 inline XnStatus SetWaveOutputMode(const XnWaveOutputMode& OutputMode) 08119 { 08120 return xnSetWaveOutputMode(GetHandle(), &OutputMode); 08121 } 08122 08134 inline XnStatus GetWaveOutputMode(XnWaveOutputMode& OutputMode) const 08135 { 08136 return xnGetWaveOutputMode(GetHandle(), &OutputMode); 08137 } 08138 08148 inline XnStatus RegisterToWaveOutputModeChanges(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 08149 { 08150 return _RegisterToStateChange(xnRegisterToWaveOutputModeChanges, GetHandle(), handler, pCookie, hCallback); 08151 } 08152 08160 inline void UnregisterFromWaveOutputModeChanges(XnCallbackHandle hCallback) 08161 { 08162 _UnregisterFromStateChange(xnUnregisterFromWaveOutputModeChanges, GetHandle(), hCallback); 08163 } 08164 }; 08165 08170 class MockAudioGenerator : public AudioGenerator 08171 { 08172 public: 08178 inline MockAudioGenerator(XnNodeHandle hNode = NULL) : AudioGenerator(hNode) {} 08179 inline MockAudioGenerator(const NodeWrapper& other) : AudioGenerator(other) {} 08180 08187 XnStatus Create(Context& context, const XnChar* strName = NULL); 08188 08196 XnStatus CreateBasedOn(AudioGenerator& other, const XnChar* strName = NULL); 08197 08202 inline XnStatus SetData(XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize, const XnUInt8* pAudioBuffer) 08203 { 08204 return xnMockAudioSetData(GetHandle(), nFrameID, nTimestamp, nDataSize, pAudioBuffer); 08205 } 08206 08215 inline XnStatus SetData(const AudioMetaData& audioMD, XnUInt32 nFrameID, XnUInt64 nTimestamp) 08216 { 08217 return SetData(nFrameID, nTimestamp, audioMD.DataSize(), audioMD.Data()); 08218 } 08219 08225 inline XnStatus SetData(const AudioMetaData& audioMD) 08226 { 08227 return SetData(audioMD, audioMD.FrameID(), audioMD.Timestamp()); 08228 } 08229 }; 08230 08234 class MockRawGenerator : public Generator 08235 { 08236 public: 08237 MockRawGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {} 08238 MockRawGenerator(const NodeWrapper& other) : Generator(other) {} 08239 08240 inline XnStatus Create(Context& context, const XnChar* strName = NULL); 08241 08242 inline XnStatus SetData(XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize, const void* pData) 08243 { 08244 return xnMockRawSetData(GetHandle(), nFrameID, nTimestamp, nDataSize, pData); 08245 } 08246 08247 }; 08248 08253 class Codec : public ProductionNode 08254 { 08255 public: 08261 inline Codec(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {} 08262 inline Codec(const NodeWrapper& other) : ProductionNode(other) {} 08263 08268 inline XnStatus Create(Context& context, XnCodecID codecID, ProductionNode& initializerNode); 08269 08274 inline XnCodecID GetCodecID() const 08275 { 08276 return xnGetCodecID(GetHandle()); 08277 } 08278 08283 inline XnStatus EncodeData(const void* pSrc, XnUInt32 nSrcSize, void* pDst, XnUInt32 nDstSize, XnUInt* pnBytesWritten) const 08284 { 08285 return xnEncodeData(GetHandle(), pSrc, nSrcSize, pDst, nDstSize, pnBytesWritten); 08286 } 08287 08292 inline XnStatus DecodeData(const void* pSrc, XnUInt32 nSrcSize, void* pDst, XnUInt32 nDstSize, XnUInt* pnBytesWritten) const 08293 { 08294 return xnDecodeData(GetHandle(), pSrc, nSrcSize, pDst, nDstSize, pnBytesWritten); 08295 } 08296 }; 08297 08331 class ScriptNode : public ProductionNode 08332 { 08333 public: 08339 inline ScriptNode(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {} 08340 inline ScriptNode(const NodeWrapper& other) : ProductionNode(other) {} 08341 08342 inline XnStatus Create(Context& context, const XnChar* strFormat); 08343 08344 inline const XnChar* GetSupportedFormat() 08345 { 08346 return xnScriptNodeGetSupportedFormat(GetHandle()); 08347 } 08348 08354 inline XnStatus LoadScriptFromFile(const XnChar* strFileName) 08355 { 08356 return xnLoadScriptFromFile(GetHandle(), strFileName); 08357 } 08358 08364 inline XnStatus LoadScriptFromString(const XnChar* strScript) 08365 { 08366 return xnLoadScriptFromString(GetHandle(), strScript); 08367 } 08368 08380 inline XnStatus Run(EnumerationErrors* pErrors); 08381 }; 08382 08383 //--------------------------------------------------------------------------- 08384 // EnumerationErrors 08385 //--------------------------------------------------------------------------- 08406 class EnumerationErrors 08407 { 08408 public: 08412 inline EnumerationErrors() : m_bAllocated(TRUE), m_pErrors(NULL) { xnEnumerationErrorsAllocate(&m_pErrors); } 08413 08421 inline EnumerationErrors(XnEnumerationErrors* pErrors, XnBool bOwn = FALSE) : m_bAllocated(bOwn), m_pErrors(pErrors) {} 08422 08426 ~EnumerationErrors() { Free(); } 08427 08431 class Iterator 08432 { 08433 public: 08434 friend class EnumerationErrors; 08435 08441 XnBool operator==(const Iterator& other) const 08442 { 08443 return m_it == other.m_it; 08444 } 08445 08451 XnBool operator!=(const Iterator& other) const 08452 { 08453 return m_it != other.m_it; 08454 } 08455 08460 inline Iterator& operator++() 08461 { 08462 m_it = xnEnumerationErrorsGetNext(m_it); 08463 return *this; 08464 } 08465 08470 inline Iterator operator++(int) 08471 { 08472 return Iterator(xnEnumerationErrorsGetNext(m_it)); 08473 } 08474 08483 inline const XnProductionNodeDescription& Description() { return *xnEnumerationErrorsGetCurrentDescription(m_it); } 08484 08489 inline XnStatus Error() { return xnEnumerationErrorsGetCurrentError(m_it); } 08490 08491 private: 08492 inline Iterator(XnEnumerationErrorsIterator it) : m_it(it) {} 08493 08494 XnEnumerationErrorsIterator m_it; 08495 }; 08496 08505 inline Iterator Begin() const { return Iterator(xnEnumerationErrorsGetFirst(m_pErrors)); } 08506 08515 inline Iterator End() const { return Iterator(NULL); } 08516 08525 inline XnStatus ToString(XnChar* csBuffer, XnUInt32 nSize) 08526 { 08527 return xnEnumerationErrorsToString(m_pErrors, csBuffer, nSize); 08528 } 08529 08534 inline void Free() 08535 { 08536 if (m_bAllocated) 08537 { 08538 xnEnumerationErrorsFree(m_pErrors); 08539 m_pErrors = NULL; 08540 m_bAllocated = FALSE; 08541 } 08542 } 08543 08547 inline XnEnumerationErrors* GetUnderlying() { return m_pErrors; } 08548 08549 private: 08550 XnEnumerationErrors* m_pErrors; 08551 XnBool m_bAllocated; 08552 }; 08553 08554 //--------------------------------------------------------------------------- 08555 // Context 08556 //--------------------------------------------------------------------------- 08557 08593 class Context 08594 { 08595 public: 08610 typedef void (XN_CALLBACK_TYPE* NodeCreationHandler)(Context& context, ProductionNode& createdNode, void* pCookie); 08611 08626 typedef void (XN_CALLBACK_TYPE* NodeDestructionHandler)(Context& context, const XnChar* strDestroyedNodeName, void* pCookie); 08627 08631 inline Context() : m_pContext(NULL), m_bUsingDeprecatedAPI(FALSE), m_bAllocated(FALSE), m_hShuttingDownCallback(NULL) {} 08632 08638 inline Context(XnContext* pContext) : m_pContext(NULL), m_bUsingDeprecatedAPI(FALSE), m_bAllocated(FALSE), m_hShuttingDownCallback(NULL) 08639 { 08640 SetHandle(pContext); 08641 } 08642 08649 inline Context(const Context& other) : m_pContext(NULL), m_bUsingDeprecatedAPI(FALSE), m_bAllocated(FALSE), m_hShuttingDownCallback(NULL) 08650 { 08651 SetHandle(other.m_pContext); 08652 } 08653 08657 ~Context() 08658 { 08659 SetHandle(NULL); 08660 } 08661 08662 inline Context& operator=(const Context& other) 08663 { 08664 SetHandle(other.m_pContext); 08665 return *this; 08666 } 08667 08671 inline XnContext* GetUnderlyingObject() const { return m_pContext; } 08672 08678 inline XnBool operator==(const Context& other) 08679 { 08680 return (GetUnderlyingObject() == other.GetUnderlyingObject()); 08681 } 08682 08688 inline XnBool operator!=(const Context& other) 08689 { 08690 return (GetUnderlyingObject() != other.GetUnderlyingObject()); 08691 } 08692 08707 inline XnStatus Init() 08708 { 08709 XnContext* pContext = NULL; 08710 XnStatus nRetVal = xnInit(&pContext); 08711 XN_IS_STATUS_OK(nRetVal); 08712 08713 TakeOwnership(pContext); 08714 m_bAllocated = TRUE; 08715 08716 return (XN_STATUS_OK); 08717 } 08718 08734 inline XnStatus RunXmlScript(const XnChar* strScript, ScriptNode& scriptNode, EnumerationErrors* pErrors = NULL) 08735 { 08736 XnStatus nRetVal = XN_STATUS_OK; 08737 08738 XnNodeHandle hScriptNode; 08739 nRetVal = xnContextRunXmlScriptEx(m_pContext, strScript, pErrors == NULL ? NULL : pErrors->GetUnderlying(), &hScriptNode); 08740 XN_IS_STATUS_OK(nRetVal); 08741 08742 scriptNode.TakeOwnership(hScriptNode); 08743 08744 return (XN_STATUS_OK); 08745 } 08746 08762 inline XnStatus RunXmlScriptFromFile(const XnChar* strFileName, ScriptNode& scriptNode, EnumerationErrors* pErrors = NULL) 08763 { 08764 XnStatus nRetVal = XN_STATUS_OK; 08765 08766 XnNodeHandle hScriptNode; 08767 nRetVal = xnContextRunXmlScriptFromFileEx(m_pContext, strFileName, pErrors == NULL ? NULL : pErrors->GetUnderlying(), &hScriptNode); 08768 XN_IS_STATUS_OK(nRetVal); 08769 08770 scriptNode.TakeOwnership(hScriptNode); 08771 08772 return (XN_STATUS_OK); 08773 } 08774 08790 inline XnStatus InitFromXmlFile(const XnChar* strFileName, ScriptNode& scriptNode, EnumerationErrors* pErrors = NULL) 08791 { 08792 XnContext* pContext = NULL; 08793 08794 XnNodeHandle hScriptNode; 08795 XnStatus nRetVal = xnInitFromXmlFileEx(strFileName, &pContext, pErrors == NULL ? NULL : pErrors->GetUnderlying(), &hScriptNode); 08796 XN_IS_STATUS_OK(nRetVal); 08797 08798 scriptNode.TakeOwnership(hScriptNode); 08799 TakeOwnership(pContext); 08800 m_bAllocated = TRUE; 08801 08802 return (XN_STATUS_OK); 08803 } 08804 08821 inline XnStatus OpenFileRecording(const XnChar* strFileName, ProductionNode& playerNode) 08822 { 08823 XnStatus nRetVal = XN_STATUS_OK; 08824 08825 XnNodeHandle hPlayer; 08826 nRetVal = xnContextOpenFileRecordingEx(m_pContext, strFileName, &hPlayer); 08827 XN_IS_STATUS_OK(nRetVal); 08828 08829 playerNode.TakeOwnership(hPlayer); 08830 08831 return (XN_STATUS_OK); 08832 } 08833 08838 inline XnStatus CreateMockNode(XnProductionNodeType type, const XnChar* strName, ProductionNode& mockNode) 08839 { 08840 XnStatus nRetVal = XN_STATUS_OK; 08841 08842 XnNodeHandle hMockNode; 08843 nRetVal = xnCreateMockNode(m_pContext, type, strName, &hMockNode); 08844 XN_IS_STATUS_OK(nRetVal); 08845 08846 mockNode.TakeOwnership(hMockNode); 08847 08848 return (XN_STATUS_OK); 08849 } 08850 08855 inline XnStatus CreateMockNodeBasedOn(ProductionNode& originalNode, const XnChar* strName, ProductionNode& mockNode) 08856 { 08857 XnStatus nRetVal = XN_STATUS_OK; 08858 08859 XnNodeHandle hMockNode; 08860 nRetVal = xnCreateMockNodeBasedOn(m_pContext, originalNode, strName, &hMockNode); 08861 XN_IS_STATUS_OK(nRetVal); 08862 08863 mockNode.TakeOwnership(hMockNode); 08864 08865 return (XN_STATUS_OK); 08866 } 08867 08872 inline XnStatus CreateCodec(XnCodecID codecID, ProductionNode& initializerNode, Codec& codec) 08873 { 08874 XnStatus nRetVal = XN_STATUS_OK; 08875 08876 XnNodeHandle hCodec; 08877 nRetVal = xnCreateCodec(m_pContext, codecID, initializerNode.GetHandle(), &hCodec); 08878 XN_IS_STATUS_OK(nRetVal); 08879 08880 codec.TakeOwnership(hCodec); 08881 08882 return (XN_STATUS_OK); 08883 } 08884 08889 inline XnStatus AddRef() 08890 { 08891 return xnContextAddRef(m_pContext); 08892 } 08893 08898 inline void Release() 08899 { 08900 SetHandle(NULL); 08901 } 08902 08903 08908 inline XnStatus AddLicense(const XnLicense& License) 08909 { 08910 return xnAddLicense(m_pContext, &License); 08911 } 08912 08917 inline XnStatus EnumerateLicenses(XnLicense*& aLicenses, XnUInt32& nCount) const 08918 { 08919 return xnEnumerateLicenses(m_pContext, &aLicenses, &nCount); 08920 } 08921 08926 inline static void FreeLicensesList(XnLicense aLicenses[]) 08927 { 08928 xnFreeLicensesList(aLicenses); 08929 } 08930 08951 XnStatus EnumerateProductionTrees(XnProductionNodeType Type, const Query* pQuery, NodeInfoList& TreesList, EnumerationErrors* pErrors = NULL) const 08952 { 08953 XnStatus nRetVal = XN_STATUS_OK; 08954 08955 const XnNodeQuery* pInternalQuery = (pQuery != NULL) ? pQuery->GetUnderlyingObject() : NULL; 08956 08957 XnNodeInfoList* pList = NULL; 08958 nRetVal = xnEnumerateProductionTrees(m_pContext, Type, pInternalQuery, &pList, pErrors == NULL ? NULL : pErrors->GetUnderlying()); 08959 XN_IS_STATUS_OK(nRetVal); 08960 08961 TreesList.ReplaceUnderlyingObject(pList); 08962 08963 return (XN_STATUS_OK); 08964 } 08965 08998 XnStatus CreateAnyProductionTree(XnProductionNodeType type, Query* pQuery, ProductionNode& node, EnumerationErrors* pErrors = NULL) 08999 { 09000 XnStatus nRetVal = XN_STATUS_OK; 09001 09002 XnNodeQuery* pInternalQuery = (pQuery != NULL) ? pQuery->GetUnderlyingObject() : NULL; 09003 09004 XnNodeHandle hNode; 09005 nRetVal = xnCreateAnyProductionTree(m_pContext, type, pInternalQuery, &hNode, pErrors == NULL ? NULL : pErrors->GetUnderlying()); 09006 XN_IS_STATUS_OK(nRetVal); 09007 09008 node.TakeOwnership(hNode); 09009 09010 return (XN_STATUS_OK); 09011 } 09012 09029 XnStatus CreateProductionTree(NodeInfo& Tree, ProductionNode& node) 09030 { 09031 XnStatus nRetVal = XN_STATUS_OK; 09032 09033 XnNodeHandle hNode; 09034 nRetVal = xnCreateProductionTree(m_pContext, Tree, &hNode); 09035 XN_IS_STATUS_OK(nRetVal); 09036 09037 node.TakeOwnership(hNode); 09038 09039 return (XN_STATUS_OK); 09040 } 09041 09050 XnStatus EnumerateExistingNodes(NodeInfoList& list) const 09051 { 09052 XnNodeInfoList* pList; 09053 XnStatus nRetVal = xnEnumerateExistingNodes(m_pContext, &pList); 09054 XN_IS_STATUS_OK(nRetVal); 09055 09056 list.ReplaceUnderlyingObject(pList); 09057 09058 return (XN_STATUS_OK); 09059 } 09060 09079 XnStatus EnumerateExistingNodes(NodeInfoList& list, XnProductionNodeType type) const 09080 { 09081 XnNodeInfoList* pList; 09082 XnStatus nRetVal = xnEnumerateExistingNodesByType(m_pContext, type, &pList); 09083 XN_IS_STATUS_OK(nRetVal); 09084 09085 list.ReplaceUnderlyingObject(pList); 09086 09087 return (XN_STATUS_OK); 09088 } 09089 09108 XnStatus FindExistingNode(XnProductionNodeType type, ProductionNode& node) const 09109 { 09110 XnStatus nRetVal = XN_STATUS_OK; 09111 09112 XnNodeHandle hNode; 09113 nRetVal = xnFindExistingRefNodeByType(m_pContext, type, &hNode); 09114 XN_IS_STATUS_OK(nRetVal); 09115 09116 node.TakeOwnership(hNode); 09117 09118 return (XN_STATUS_OK); 09119 } 09120 09125 XnStatus GetProductionNodeByName(const XnChar* strInstanceName, ProductionNode& node) const 09126 { 09127 XnStatus nRetVal = XN_STATUS_OK; 09128 09129 XnNodeHandle hNode; 09130 nRetVal = xnGetRefNodeHandleByName(m_pContext, strInstanceName, &hNode); 09131 XN_IS_STATUS_OK(nRetVal); 09132 09133 node.TakeOwnership(hNode); 09134 09135 return (XN_STATUS_OK); 09136 } 09137 09142 XnStatus GetProductionNodeInfoByName(const XnChar* strInstanceName, NodeInfo& nodeInfo) const 09143 { 09144 XnStatus nRetVal = XN_STATUS_OK; 09145 09146 XnNodeHandle hNode; 09147 nRetVal = xnGetRefNodeHandleByName(m_pContext, strInstanceName, &hNode); 09148 XN_IS_STATUS_OK(nRetVal); 09149 09150 xnProductionNodeRelease(hNode); 09151 09152 nodeInfo = NodeInfo(xnGetNodeInfo(hNode)); 09153 09154 return (XN_STATUS_OK); 09155 } 09156 09161 inline XnStatus StartGeneratingAll() 09162 { 09163 return xnStartGeneratingAll(m_pContext); 09164 } 09165 09169 inline XnStatus StopGeneratingAll() 09170 { 09171 return xnStopGeneratingAll(m_pContext); 09172 } 09173 09183 inline XnStatus SetGlobalMirror(XnBool bMirror) 09184 { 09185 return xnSetGlobalMirror(m_pContext, bMirror); 09186 } 09187 09192 inline XnBool GetGlobalMirror() 09193 { 09194 return xnGetGlobalMirror(m_pContext); 09195 } 09196 09201 inline XnStatus GetGlobalErrorState() 09202 { 09203 return xnGetGlobalErrorState(m_pContext); 09204 } 09205 09215 inline XnStatus RegisterToErrorStateChange(XnErrorStateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 09216 { 09217 return xnRegisterToGlobalErrorStateChange(m_pContext, handler, pCookie, &hCallback); 09218 } 09219 09227 inline void UnregisterFromErrorStateChange(XnCallbackHandle hCallback) 09228 { 09229 xnUnregisterFromGlobalErrorStateChange(m_pContext, hCallback); 09230 } 09231 09241 inline XnStatus RegisterToNodeCreation(NodeCreationHandler handler, void* pCookie, XnCallbackHandle& hCallback) 09242 { 09243 XnStatus nRetVal = XN_STATUS_OK; 09244 09245 NodeCreationCookie* pCreationCookie; 09246 XN_VALIDATE_ALLOC(pCreationCookie, NodeCreationCookie); 09247 pCreationCookie->pFunc = handler; 09248 pCreationCookie->pCookie = pCookie; 09249 09250 nRetVal = xnRegisterToNodeCreation(m_pContext, NodeCreationCallback, pCreationCookie, &pCreationCookie->hUnderlyingCallback); 09251 XN_IS_STATUS_OK(nRetVal); 09252 09253 hCallback = pCreationCookie; 09254 09255 return XN_STATUS_OK; 09256 } 09257 09265 inline void UnregisterFromNodeCreation(XnCallbackHandle hCallback) 09266 { 09267 NodeCreationCookie* pCreationCookie = (NodeCreationCookie*)hCallback; 09268 xnUnregisterFromNodeCreation(m_pContext, pCreationCookie->hUnderlyingCallback); 09269 xnOSFree(pCreationCookie); 09270 } 09271 09281 inline XnStatus RegisterToNodeDestruction(NodeDestructionHandler handler, void* pCookie, XnCallbackHandle& hCallback) 09282 { 09283 XnStatus nRetVal = XN_STATUS_OK; 09284 09285 NodeDestructionCookie* pDestructionCookie; 09286 XN_VALIDATE_ALLOC(pDestructionCookie, NodeDestructionCookie); 09287 pDestructionCookie->pFunc = handler; 09288 pDestructionCookie->pCookie = pCookie; 09289 09290 nRetVal = xnRegisterToNodeDestruction(m_pContext, NodeDestructionCallback, pDestructionCookie, &pDestructionCookie->hUnderlyingCallback); 09291 XN_IS_STATUS_OK(nRetVal); 09292 09293 hCallback = pDestructionCookie; 09294 09295 return XN_STATUS_OK; 09296 } 09297 09305 inline void UnregisterFromNodeDestruction(XnCallbackHandle hCallback) 09306 { 09307 NodeDestructionCookie* pDestructionCookie = (NodeDestructionCookie*)hCallback; 09308 xnUnregisterFromNodeDestruction(m_pContext, pDestructionCookie->hUnderlyingCallback); 09309 xnOSFree(pDestructionCookie); 09310 } 09311 09345 inline XnStatus WaitAndUpdateAll() 09346 { 09347 return xnWaitAndUpdateAll(m_pContext); 09348 } 09349 09384 inline XnStatus WaitAnyUpdateAll() 09385 { 09386 return xnWaitAnyUpdateAll(m_pContext); 09387 } 09388 09419 inline XnStatus WaitOneUpdateAll(ProductionNode& node) 09420 { 09421 return xnWaitOneUpdateAll(m_pContext, node.GetHandle()); 09422 } 09423 09445 inline XnStatus WaitNoneUpdateAll() 09446 { 09447 return xnWaitNoneUpdateAll(m_pContext); 09448 } 09449 09454 inline XnStatus AutoEnumerateOverSingleInput(NodeInfoList& List, XnProductionNodeDescription& description, const XnChar* strCreationInfo, XnProductionNodeType InputType, EnumerationErrors* pErrors, Query* pQuery = NULL) const 09455 { 09456 return xnAutoEnumerateOverSingleInput(m_pContext, List.GetUnderlyingObject(), &description, strCreationInfo, InputType, pErrors == NULL ? NULL : pErrors->GetUnderlying(), pQuery == NULL ? NULL : pQuery->GetUnderlyingObject()); 09457 } 09458 09462 inline void SetHandle(XnContext* pContext) 09463 { 09464 if (m_pContext == pContext) 09465 { 09466 return; 09467 } 09468 09469 if (m_pContext != NULL) 09470 { 09471 if (m_bUsingDeprecatedAPI && m_bAllocated) 09472 { 09473 // Backwards compatibility: call shutdown instead of release, to make old programs get the 09474 // exact same behavior they used to have. 09475 xnForceShutdown(m_pContext); 09476 } 09477 else 09478 { 09479 xnContextUnregisterFromShutdown(m_pContext, m_hShuttingDownCallback); 09480 xnContextRelease(m_pContext); 09481 } 09482 } 09483 09484 if (pContext != NULL) 09485 { 09486 XnStatus nRetVal = xnContextAddRef(pContext); 09487 XN_ASSERT(nRetVal == XN_STATUS_OK); 09488 XN_REFERENCE_VARIABLE(nRetVal); 09489 09490 nRetVal = xnContextRegisterForShutdown(pContext, ContextShuttingDownCallback, this, &m_hShuttingDownCallback); 09491 XN_ASSERT(nRetVal == XN_STATUS_OK); 09492 } 09493 09494 m_pContext = pContext; 09495 } 09496 09497 inline void TakeOwnership(XnContext* pContext) 09498 { 09499 SetHandle(pContext); 09500 09501 if (pContext != NULL) 09502 { 09503 xnContextRelease(pContext); 09504 } 09505 } 09506 09508 inline XnStatus XN_API_DEPRECATED("Use other overload!") RunXmlScript(const XnChar* strScript, EnumerationErrors* pErrors = NULL) 09509 { 09510 m_bUsingDeprecatedAPI = TRUE; 09511 #pragma warning (push) 09512 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS) 09513 return xnContextRunXmlScript(m_pContext, strScript, pErrors == NULL ? NULL : pErrors->GetUnderlying()); 09514 #pragma warning (pop) 09515 } 09516 09517 inline XnStatus XN_API_DEPRECATED("Use other overload!") RunXmlScriptFromFile(const XnChar* strFileName, EnumerationErrors* pErrors = NULL) 09518 { 09519 m_bUsingDeprecatedAPI = TRUE; 09520 #pragma warning (push) 09521 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS) 09522 return xnContextRunXmlScriptFromFile(m_pContext, strFileName, pErrors == NULL ? NULL : pErrors->GetUnderlying()); 09523 #pragma warning (pop) 09524 } 09525 09526 inline XnStatus XN_API_DEPRECATED("Use other overload!") InitFromXmlFile(const XnChar* strFileName, EnumerationErrors* pErrors = NULL) 09527 { 09528 XnContext* pContext = NULL; 09529 m_bUsingDeprecatedAPI = TRUE; 09530 09531 #pragma warning (push) 09532 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS) 09533 XnStatus nRetVal = xnInitFromXmlFile(strFileName, &pContext, pErrors == NULL ? NULL : pErrors->GetUnderlying()); 09534 #pragma warning (pop) 09535 XN_IS_STATUS_OK(nRetVal); 09536 09537 TakeOwnership(pContext); 09538 m_bAllocated = TRUE; 09539 09540 return (XN_STATUS_OK); 09541 } 09542 09543 inline XnStatus XN_API_DEPRECATED("Use other overload!") OpenFileRecording(const XnChar* strFileName) 09544 { 09545 m_bUsingDeprecatedAPI = TRUE; 09546 #pragma warning (push) 09547 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS) 09548 return xnContextOpenFileRecording(m_pContext, strFileName); 09549 #pragma warning (pop) 09550 } 09551 09552 inline void XN_API_DEPRECATED("You may use Release() instead, or count on dtor") Shutdown() 09553 { 09554 if (m_pContext != NULL) 09555 { 09556 #pragma warning (push) 09557 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS) 09558 xnShutdown(m_pContext); 09559 #pragma warning (pop) 09560 m_pContext = NULL; 09561 } 09562 } 09563 09564 XnStatus XN_API_DEPRECATED("Please use other overload") CreateProductionTree(NodeInfo& Tree) 09565 { 09566 XnStatus nRetVal = XN_STATUS_OK; 09567 09568 XnNodeHandle hNode; 09569 nRetVal = xnCreateProductionTree(m_pContext, Tree, &hNode); 09570 XN_IS_STATUS_OK(nRetVal); 09571 09572 Tree.m_bOwnerOfNode = TRUE; 09573 09574 return (XN_STATUS_OK); 09575 } 09578 private: 09579 typedef struct NodeCreationCookie 09580 { 09581 NodeCreationHandler pFunc; 09582 void* pCookie; 09583 XnCallbackHandle hUnderlyingCallback; 09584 } NodeCreationCookie; 09585 09586 typedef struct NodeDestructionCookie 09587 { 09588 NodeDestructionHandler pFunc; 09589 void* pCookie; 09590 XnCallbackHandle hUnderlyingCallback; 09591 } NodeDestructionCookie; 09592 09593 static void XN_CALLBACK_TYPE NodeCreationCallback(XnContext* pContext, XnNodeHandle hCreatedNode, void* pCookie) 09594 { 09595 NodeCreationCookie* pNodeCreationCookie = (NodeCreationCookie*)pCookie; 09596 Context context(pContext); 09597 ProductionNode createdNode(hCreatedNode); 09598 pNodeCreationCookie->pFunc(context, createdNode, pNodeCreationCookie->pCookie); 09599 } 09600 09601 static void XN_CALLBACK_TYPE NodeDestructionCallback(XnContext* pContext, const XnChar* strDestroyedNodeName, void* pCookie) 09602 { 09603 NodeDestructionCookie* pNodeCreationCookie = (NodeDestructionCookie*)pCookie; 09604 Context context(pContext); 09605 pNodeCreationCookie->pFunc(context, strDestroyedNodeName, pNodeCreationCookie->pCookie); 09606 } 09607 09608 static void XN_CALLBACK_TYPE ContextShuttingDownCallback(XnContext* /*pContext*/, void* pCookie) 09609 { 09610 Context* pThis = (Context*)pCookie; 09611 pThis->m_pContext = NULL; 09612 } 09613 09614 XnContext* m_pContext; 09615 XnBool m_bUsingDeprecatedAPI; 09616 XnBool m_bAllocated; 09617 XnCallbackHandle m_hShuttingDownCallback; 09618 }; 09619 09624 class Resolution 09625 { 09626 public: 09632 inline Resolution(XnResolution res) : m_Res(res) 09633 { 09634 m_nXRes = xnResolutionGetXRes(res); 09635 m_nYRes = xnResolutionGetYRes(res); 09636 m_strName = xnResolutionGetName(res); 09637 } 09638 09645 inline Resolution(XnUInt32 xRes, XnUInt32 yRes) : m_nXRes(xRes), m_nYRes(yRes) 09646 { 09647 m_Res = xnResolutionGetFromXYRes(xRes, yRes); 09648 m_strName = xnResolutionGetName(m_Res); 09649 } 09650 09656 inline Resolution(const XnChar* strName) 09657 { 09658 m_Res = xnResolutionGetFromName(strName); 09659 m_nXRes = xnResolutionGetXRes(m_Res); 09660 m_nYRes = xnResolutionGetYRes(m_Res); 09661 m_strName = xnResolutionGetName(m_Res); 09662 } 09663 09667 inline XnResolution GetResolution() const { return m_Res; } 09671 inline XnUInt32 GetXResolution() const { return m_nXRes; } 09675 inline XnUInt32 GetYResolution() const { return m_nYRes; } 09679 inline const XnChar* GetName() const { return m_strName; } 09680 09681 private: 09682 XnResolution m_Res; 09683 XnUInt32 m_nXRes; 09684 XnUInt32 m_nYRes; 09685 const XnChar* m_strName; 09686 }; 09687 09688 //--------------------------------------------------------------------------- 09689 // Functions Implementation 09690 //--------------------------------------------------------------------------- 09691 inline XnStatus NodeInfoList::FilterList(Context& context, Query& query) 09692 { 09693 return xnNodeQueryFilterList(context.GetUnderlyingObject(), query.GetUnderlyingObject(), m_pList); 09694 } 09695 09696 inline void ProductionNode::GetContext(Context& context) const 09697 { 09698 context.TakeOwnership(xnGetRefContextFromNodeHandle(GetHandle())); 09699 } 09700 09701 inline Context ProductionNode::GetContext() const 09702 { 09703 XnContext* pContext = xnGetRefContextFromNodeHandle(GetHandle()); 09704 Context result(pContext); 09705 xnContextRelease(pContext); 09706 return result; 09707 } 09708 09709 inline NodeInfoList& NodeInfo::GetNeededNodes() const 09710 { 09711 if (m_pNeededNodes == NULL) 09712 { 09713 XnNodeInfoList* pList = xnNodeInfoGetNeededNodes(m_pInfo); 09714 m_pNeededNodes = XN_NEW(NodeInfoList, pList); 09715 } 09716 09717 return *m_pNeededNodes; 09718 } 09719 09720 inline void NodeInfo::SetUnderlyingObject(XnNodeInfo* pInfo) 09721 { 09722 if (m_pNeededNodes != NULL) 09723 { 09724 XN_DELETE(m_pNeededNodes); 09725 } 09726 09727 m_bOwnerOfNode = FALSE; 09728 m_pInfo = pInfo; 09729 m_pNeededNodes = NULL; 09730 } 09731 09732 inline XnBool FrameSyncCapability::CanFrameSyncWith(Generator& other) const 09733 { 09734 return xnCanFrameSyncWith(GetHandle(), other.GetHandle()); 09735 } 09736 09737 inline XnStatus FrameSyncCapability::FrameSyncWith(Generator& other) 09738 { 09739 return xnFrameSyncWith(GetHandle(), other.GetHandle()); 09740 } 09741 09742 inline XnStatus FrameSyncCapability::StopFrameSyncWith(Generator& other) 09743 { 09744 return xnStopFrameSyncWith(GetHandle(), other.GetHandle()); 09745 } 09746 09747 inline XnBool FrameSyncCapability::IsFrameSyncedWith(Generator& other) const 09748 { 09749 return xnIsFrameSyncedWith(GetHandle(), other.GetHandle()); 09750 } 09751 09752 inline XnStatus NodeInfo::GetInstance(ProductionNode& node) const 09753 { 09754 if (m_pInfo == NULL) 09755 { 09756 return XN_STATUS_INVALID_OPERATION; 09757 } 09758 09759 XnNodeHandle hNode = xnNodeInfoGetRefHandle(m_pInfo); 09760 node.TakeOwnership(hNode); 09761 09762 if (m_bOwnerOfNode) 09763 { 09764 xnProductionNodeRelease(hNode); 09765 } 09766 09767 return (XN_STATUS_OK); 09768 } 09769 09770 //--------------------------------------------------------------------------- 09771 // Node creation functions 09772 //--------------------------------------------------------------------------- 09773 09774 inline XnStatus Device::Create(Context& context, Query* pQuery/*=NULL*/, EnumerationErrors* pErrors/*=NULL*/) 09775 { 09776 XnNodeHandle hNode; 09777 XnStatus nRetVal = xnCreateDevice(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying()); 09778 XN_IS_STATUS_OK(nRetVal); 09779 TakeOwnership(hNode); 09780 return (XN_STATUS_OK); 09781 } 09782 09783 inline XnStatus Recorder::Create(Context& context, const XnChar* strFormatName /*= NULL*/) 09784 { 09785 XnNodeHandle hNode; 09786 XnStatus nRetVal = xnCreateRecorder(context.GetUnderlyingObject(), strFormatName, &hNode); 09787 XN_IS_STATUS_OK(nRetVal); 09788 TakeOwnership(hNode); 09789 return (XN_STATUS_OK); 09790 } 09791 09792 inline XnStatus Player::Create(Context& context, const XnChar* strFormatName) 09793 { 09794 XnNodeHandle hNode; 09795 XnStatus nRetVal = xnCreatePlayer(context.GetUnderlyingObject(), strFormatName, &hNode); 09796 XN_IS_STATUS_OK(nRetVal); 09797 TakeOwnership(hNode); 09798 return (XN_STATUS_OK); 09799 } 09800 09801 inline XnStatus DepthGenerator::Create(Context& context, Query* pQuery/*=NULL*/, EnumerationErrors* pErrors/*=NULL*/) 09802 { 09803 XnNodeHandle hNode; 09804 XnStatus nRetVal = xnCreateDepthGenerator(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying()); 09805 XN_IS_STATUS_OK(nRetVal); 09806 TakeOwnership(hNode); 09807 return (XN_STATUS_OK); 09808 } 09809 09810 inline XnStatus MockDepthGenerator::Create(Context& context, const XnChar* strName /* = NULL */) 09811 { 09812 XnNodeHandle hNode; 09813 XnStatus nRetVal = xnCreateMockNode(context.GetUnderlyingObject(), XN_NODE_TYPE_DEPTH, strName, &hNode); 09814 XN_IS_STATUS_OK(nRetVal); 09815 TakeOwnership(hNode); 09816 return (XN_STATUS_OK); 09817 } 09818 09819 inline XnStatus MockDepthGenerator::CreateBasedOn(DepthGenerator& other, const XnChar* strName /* = NULL */) 09820 { 09821 Context context; 09822 other.GetContext(context); 09823 XnNodeHandle hNode; 09824 XnStatus nRetVal = xnCreateMockNodeBasedOn(context.GetUnderlyingObject(), other.GetHandle(), strName, &hNode); 09825 XN_IS_STATUS_OK(nRetVal); 09826 TakeOwnership(hNode); 09827 return (XN_STATUS_OK); 09828 } 09829 09830 inline XnStatus ImageGenerator::Create(Context& context, Query* pQuery/*=NULL*/, EnumerationErrors* pErrors/*=NULL*/) 09831 { 09832 XnNodeHandle hNode; 09833 XnStatus nRetVal = xnCreateImageGenerator(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying()); 09834 XN_IS_STATUS_OK(nRetVal); 09835 TakeOwnership(hNode); 09836 return (XN_STATUS_OK); 09837 } 09838 09839 inline XnStatus MockImageGenerator::Create(Context& context, const XnChar* strName /* = NULL */) 09840 { 09841 XnNodeHandle hNode; 09842 XnStatus nRetVal = xnCreateMockNode(context.GetUnderlyingObject(), XN_NODE_TYPE_IMAGE, strName, &hNode); 09843 XN_IS_STATUS_OK(nRetVal); 09844 TakeOwnership(hNode); 09845 return (XN_STATUS_OK); 09846 } 09847 09848 inline XnStatus MockImageGenerator::CreateBasedOn(ImageGenerator& other, const XnChar* strName /* = NULL */) 09849 { 09850 Context context; 09851 other.GetContext(context); 09852 XnNodeHandle hNode; 09853 XnStatus nRetVal = xnCreateMockNodeBasedOn(context.GetUnderlyingObject(), other.GetHandle(), strName, &hNode); 09854 XN_IS_STATUS_OK(nRetVal); 09855 TakeOwnership(hNode); 09856 return (XN_STATUS_OK); 09857 } 09858 09859 inline XnStatus IRGenerator::Create(Context& context, Query* pQuery/*=NULL*/, EnumerationErrors* pErrors/*=NULL*/) 09860 { 09861 XnNodeHandle hNode; 09862 XnStatus nRetVal = xnCreateIRGenerator(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying()); 09863 XN_IS_STATUS_OK(nRetVal); 09864 TakeOwnership(hNode); 09865 return (XN_STATUS_OK); 09866 } 09867 09868 inline XnStatus MockIRGenerator::Create(Context& context, const XnChar* strName /* = NULL */) 09869 { 09870 XnNodeHandle hNode; 09871 XnStatus nRetVal = xnCreateMockNode(context.GetUnderlyingObject(), XN_NODE_TYPE_IR, strName, &hNode); 09872 XN_IS_STATUS_OK(nRetVal); 09873 TakeOwnership(hNode); 09874 return (XN_STATUS_OK); 09875 } 09876 09877 inline XnStatus MockIRGenerator::CreateBasedOn(IRGenerator& other, const XnChar* strName /* = NULL */) 09878 { 09879 Context context; 09880 other.GetContext(context); 09881 XnNodeHandle hNode; 09882 XnStatus nRetVal = xnCreateMockNodeBasedOn(context.GetUnderlyingObject(), other.GetHandle(), strName, &hNode); 09883 XN_IS_STATUS_OK(nRetVal); 09884 TakeOwnership(hNode); 09885 return (XN_STATUS_OK); 09886 } 09887 09888 inline XnStatus GestureGenerator::Create(Context& context, Query* pQuery/*=NULL*/, EnumerationErrors* pErrors/*=NULL*/) 09889 { 09890 XnNodeHandle hNode; 09891 XnStatus nRetVal = xnCreateGestureGenerator(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying()); 09892 XN_IS_STATUS_OK(nRetVal); 09893 TakeOwnership(hNode); 09894 return (XN_STATUS_OK); 09895 } 09896 09897 inline XnStatus SceneAnalyzer::Create(Context& context, Query* pQuery/*=NULL*/, EnumerationErrors* pErrors/*=NULL*/) 09898 { 09899 //You're creating a scene! 09900 XnNodeHandle hNode; 09901 XnStatus nRetVal = xnCreateSceneAnalyzer(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying()); 09902 XN_IS_STATUS_OK(nRetVal); 09903 TakeOwnership(hNode); 09904 return (XN_STATUS_OK); 09905 } 09906 09907 inline XnStatus HandsGenerator::Create(Context& context, Query* pQuery/*=NULL*/, EnumerationErrors* pErrors/*=NULL*/) 09908 { 09909 XnNodeHandle hNode; 09910 XnStatus nRetVal = xnCreateHandsGenerator(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying()); 09911 XN_IS_STATUS_OK(nRetVal); 09912 TakeOwnership(hNode); 09913 return (XN_STATUS_OK); 09914 } 09915 09916 inline XnStatus UserGenerator::Create(Context& context, Query* pQuery/*=NULL*/, EnumerationErrors* pErrors/*=NULL*/) 09917 { 09918 XnNodeHandle hNode; 09919 XnStatus nRetVal = xnCreateUserGenerator(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying()); 09920 XN_IS_STATUS_OK(nRetVal); 09921 TakeOwnership(hNode); 09922 return (XN_STATUS_OK); 09923 } 09924 09925 inline XnStatus AudioGenerator::Create(Context& context, Query* pQuery/*=NULL*/, EnumerationErrors* pErrors/*=NULL*/) 09926 { 09927 XnNodeHandle hNode; 09928 XnStatus nRetVal = xnCreateAudioGenerator(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying()); 09929 XN_IS_STATUS_OK(nRetVal); 09930 TakeOwnership(hNode); 09931 return (XN_STATUS_OK); 09932 } 09933 09934 inline XnStatus MockAudioGenerator::Create(Context& context, const XnChar* strName /* = NULL */) 09935 { 09936 XnNodeHandle hNode; 09937 XnStatus nRetVal = xnCreateMockNode(context.GetUnderlyingObject(), XN_NODE_TYPE_AUDIO, strName, &hNode); 09938 XN_IS_STATUS_OK(nRetVal); 09939 TakeOwnership(hNode); 09940 return (XN_STATUS_OK); 09941 } 09942 09943 inline XnStatus MockAudioGenerator::CreateBasedOn(AudioGenerator& other, const XnChar* strName /* = NULL */) 09944 { 09945 Context context; 09946 other.GetContext(context); 09947 XnNodeHandle hNode; 09948 XnStatus nRetVal = xnCreateMockNodeBasedOn(context.GetUnderlyingObject(), other.GetHandle(), strName, &hNode); 09949 XN_IS_STATUS_OK(nRetVal); 09950 TakeOwnership(hNode); 09951 return (XN_STATUS_OK); 09952 } 09953 09954 inline XnStatus MockRawGenerator::Create(Context& context, const XnChar* strName /*= NULL*/) 09955 { 09956 XnNodeHandle hNode; 09957 XnStatus nRetVal = xnCreateMockNode(context.GetUnderlyingObject(), XN_NODE_TYPE_GENERATOR, strName, &hNode); 09958 XN_IS_STATUS_OK(nRetVal); 09959 TakeOwnership(hNode); 09960 return (XN_STATUS_OK); 09961 } 09962 09963 inline XnStatus Codec::Create(Context& context, XnCodecID codecID, ProductionNode& initializerNode) 09964 { 09965 XnNodeHandle hNode; 09966 XnStatus nRetVal = xnCreateCodec(context.GetUnderlyingObject(), codecID, initializerNode.GetHandle(), &hNode); 09967 XN_IS_STATUS_OK(nRetVal); 09968 TakeOwnership(hNode); 09969 return (XN_STATUS_OK); 09970 } 09971 09972 inline XnStatus ScriptNode::Run(EnumerationErrors* pErrors) 09973 { 09974 return xnScriptNodeRun(GetHandle(), pErrors == NULL ? NULL : pErrors->GetUnderlying()); 09975 } 09976 09977 inline XnStatus ScriptNode::Create(Context& context, const XnChar* strFormat) 09978 { 09979 XnNodeHandle hNode; 09980 XnStatus nRetVal = xnCreateScriptNode(context.GetUnderlyingObject(), strFormat, &hNode); 09981 XN_IS_STATUS_OK(nRetVal); 09982 TakeOwnership(hNode); 09983 return (XN_STATUS_OK); 09984 } 09985 09986 //--------------------------------------------------------------------------- 09987 // Global Helper Functions 09988 //--------------------------------------------------------------------------- 09989 09990 inline void XN_API_DEPRECATED("Use xn::Version::Current() instead") GetVersion(XnVersion& Version) 09991 { 09992 xnGetVersion(&Version); 09993 } 09994 09995 //--------------------------------------------------------------------------- 09996 // Internal Helper Classes and Functions 09997 //--------------------------------------------------------------------------- 09998 09999 class StateChangedCallbackTranslator 10000 { 10001 public: 10002 StateChangedCallbackTranslator(StateChangedHandler handler, void* pCookie) : m_UserHandler(handler), m_pUserCookie(pCookie), m_hCallback(NULL) {} 10003 10004 XnStatus Register(_XnRegisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode) 10005 { 10006 return xnFunc(hNode, StateChangedCallback, this, &m_hCallback); 10007 } 10008 10009 void Unregister(_XnUnregisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode) 10010 { 10011 xnFunc(hNode, m_hCallback); 10012 } 10013 10014 static XnStatus RegisterToUnderlying(_XnRegisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode, StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 10015 { 10016 XnStatus nRetVal = XN_STATUS_OK; 10017 10018 StateChangedCallbackTranslator* pTrans; 10019 XN_VALIDATE_NEW(pTrans, StateChangedCallbackTranslator, handler, pCookie); 10020 10021 nRetVal = pTrans->Register(xnFunc, hNode); 10022 if (nRetVal != XN_STATUS_OK) 10023 { 10024 XN_DELETE(pTrans); 10025 return (nRetVal); 10026 } 10027 10028 hCallback = pTrans; 10029 10030 return (XN_STATUS_OK); 10031 } 10032 10033 static XnStatus UnregisterFromUnderlying(_XnUnregisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode, XnCallbackHandle hCallback) 10034 { 10035 StateChangedCallbackTranslator* pTrans = (StateChangedCallbackTranslator*)hCallback; 10036 pTrans->Unregister(xnFunc, hNode); 10037 XN_DELETE(pTrans); 10038 return XN_STATUS_OK; 10039 } 10040 10041 private: 10042 friend class GeneralIntCapability; 10043 10044 typedef struct StateChangeCookie 10045 { 10046 StateChangedHandler userHandler; 10047 void* pUserCookie; 10048 XnCallbackHandle hCallback; 10049 } StateChangeCookie; 10050 10051 static void XN_CALLBACK_TYPE StateChangedCallback(XnNodeHandle hNode, void* pCookie) 10052 { 10053 StateChangedCallbackTranslator* pTrans = (StateChangedCallbackTranslator*)pCookie; 10054 ProductionNode node(hNode); 10055 pTrans->m_UserHandler(node, pTrans->m_pUserCookie); 10056 } 10057 10058 StateChangedHandler m_UserHandler; 10059 void* m_pUserCookie; 10060 XnCallbackHandle m_hCallback; 10061 }; 10062 10063 static XnStatus _RegisterToStateChange(_XnRegisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode, StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 10064 { 10065 return StateChangedCallbackTranslator::RegisterToUnderlying(xnFunc, hNode, handler, pCookie, hCallback); 10066 } 10067 10068 static void _UnregisterFromStateChange(_XnUnregisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode, XnCallbackHandle hCallback) 10069 { 10070 StateChangedCallbackTranslator::UnregisterFromUnderlying(xnFunc, hNode, hCallback); 10071 } 10072 10073 inline XnStatus GeneralIntCapability::RegisterToValueChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 10074 { 10075 XnStatus nRetVal = XN_STATUS_OK; 10076 10077 StateChangedCallbackTranslator* pTrans; 10078 XN_VALIDATE_NEW(pTrans, StateChangedCallbackTranslator, handler, pCookie); 10079 10080 nRetVal = xnRegisterToGeneralIntValueChange(GetHandle(), m_strCap, pTrans->StateChangedCallback, pTrans, &pTrans->m_hCallback); 10081 if (nRetVal != XN_STATUS_OK) 10082 { 10083 XN_DELETE(pTrans); 10084 return (nRetVal); 10085 } 10086 10087 hCallback = pTrans; 10088 10089 return (XN_STATUS_OK); 10090 } 10091 10092 inline void GeneralIntCapability::UnregisterFromValueChange(XnCallbackHandle hCallback) 10093 { 10094 StateChangedCallbackTranslator* pTrans = (StateChangedCallbackTranslator*)hCallback; 10095 xnUnregisterFromGeneralIntValueChange(GetHandle(), m_strCap, pTrans->m_hCallback); 10096 XN_DELETE(pTrans); 10097 } 10098 }; 10099 10100 #endif // __XN_CPP_WRAPPER_H__
Generated on Wed May 16 2012 10:16:05 for OpenNI 1.5.4 by
1.7.5.1