OpenNI 1.5.2
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 
00052     //---------------------------------------------------------------------------
00053     // Types
00054     //---------------------------------------------------------------------------
00055 
00062     typedef void (XN_CALLBACK_TYPE* StateChangedHandler)(ProductionNode& node, void* pCookie);
00063 
00064     //---------------------------------------------------------------------------
00065     // Internal stuff
00066     //---------------------------------------------------------------------------
00067     typedef XnStatus (*_XnRegisterStateChangeFuncPtr)(XnNodeHandle hNode, XnStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback);
00068     typedef void (*_XnUnregisterStateChangeFuncPtr)(XnNodeHandle hNode, XnCallbackHandle hCallback);
00069 
00070     static XnStatus _RegisterToStateChange(_XnRegisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode, StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback);
00071     static void _UnregisterFromStateChange(_XnUnregisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode, XnCallbackHandle hCallback);
00072 
00073     //---------------------------------------------------------------------------
00074     // Some Utilities
00075     //---------------------------------------------------------------------------
00076     class Version
00077     {
00078     public:
00079         Version(const XnVersion& version) : m_version(version) {}
00080         Version(XnUInt8 nMajor, XnUInt8 nMinor, XnUInt16 nMaintenance, XnUInt32 nBuild)
00081         {
00082             m_version.nMajor = nMajor;
00083             m_version.nMinor = nMinor;
00084             m_version.nMaintenance = nMaintenance;
00085             m_version.nBuild = nBuild;
00086         }
00087 
00088         bool operator==(const Version& other) const
00089         {
00090             return (xnVersionCompare(&m_version, &other.m_version) == 0);
00091         }
00092         bool operator!=(const Version& other) const
00093         {
00094             return (xnVersionCompare(&m_version, &other.m_version) != 0);
00095         }
00096         bool operator<(const Version& other) const 
00097         {
00098             return (xnVersionCompare(&m_version, &other.m_version) < 0);
00099         }
00100         bool operator<=(const Version& other) const
00101         {
00102             return (xnVersionCompare(&m_version, &other.m_version) <= 0);
00103         }
00104         bool operator>(const Version& other) const
00105         {
00106             return (xnVersionCompare(&m_version, &other.m_version) > 0);
00107         }
00108         bool operator>=(const Version& other) const
00109         {
00110             return (xnVersionCompare(&m_version, &other.m_version) >= 0);
00111         }
00112     private:
00113         XnVersion m_version;
00114     };
00115 
00116     //---------------------------------------------------------------------------
00117     // Meta Data
00118     //---------------------------------------------------------------------------
00119 
00124     class OutputMetaData
00125     {
00126     public:
00132         inline OutputMetaData(const XnUInt8** ppData) : m_ppData(ppData), m_nAllocatedSize(0), m_pAllocatedData(NULL)
00133         {
00134             xnOSMemSet(&m_output, 0, sizeof(XnOutputMetaData));
00135         }
00136 
00140         virtual ~OutputMetaData() { Free(); }
00141 
00143         inline XnUInt64 Timestamp() const { return m_output.nTimestamp; }
00145         inline XnUInt64& Timestamp() { return m_output.nTimestamp; }
00146 
00148         inline XnUInt32 FrameID() const { return m_output.nFrameID; }
00150         inline XnUInt32& FrameID() { return m_output.nFrameID; }
00151 
00153         inline XnUInt32 DataSize() const { return m_output.nDataSize; }
00155         inline XnUInt32& DataSize() { return m_output.nDataSize; }
00156 
00158         inline XnBool IsDataNew() const { return m_output.bIsNew; }
00160         inline XnBool& IsDataNew() { return m_output.bIsNew; }
00161 
00163         inline const XnOutputMetaData* GetUnderlying() const { return &m_output; }
00165         inline XnOutputMetaData* GetUnderlying() { return &m_output; }
00166 
00168         inline const XnUInt8* Data() const { return *m_ppData; }
00170         inline const XnUInt8*& Data() { return *m_ppData; }
00172         inline XnUInt8* WritableData()
00173         {
00174             MakeDataWritable();
00175             return m_pAllocatedData;
00176         }
00177 
00184         XnStatus AllocateData(XnUInt32 nBytes)
00185         {
00186             if (nBytes > m_nAllocatedSize)
00187             {
00188                 // reallocate
00189                 XnUInt8* pData = (XnUInt8*)xnOSMallocAligned(nBytes, XN_DEFAULT_MEM_ALIGN);
00190                 XN_VALIDATE_ALLOC_PTR(pData);
00191 
00192                 // allocation succeeded, replace
00193                 Free();
00194                 m_pAllocatedData = pData;
00195                 m_nAllocatedSize = nBytes;
00196             }
00197 
00198             DataSize() = nBytes;
00199             *m_ppData = m_pAllocatedData;
00200 
00201             return XN_STATUS_OK;
00202         }
00203 
00207         void Free()
00208         {
00209             if (m_nAllocatedSize != 0)
00210             {
00211                 xnOSFreeAligned(m_pAllocatedData);
00212                 m_pAllocatedData = NULL;
00213                 m_nAllocatedSize = 0;
00214             }
00215         }
00216 
00221         XnStatus MakeDataWritable()
00222         {
00223             XnStatus nRetVal = XN_STATUS_OK;
00224 
00225             // check data isn't already writable
00226             if (Data() != m_pAllocatedData || DataSize() > m_nAllocatedSize)
00227             {
00228                 const XnUInt8* pOrigData = *m_ppData;
00229 
00230                 nRetVal = AllocateData(DataSize());
00231                 XN_IS_STATUS_OK(nRetVal);
00232 
00233                 if (pOrigData != NULL)
00234                 {
00235                     xnOSMemCopy(m_pAllocatedData, pOrigData, DataSize());
00236                 }
00237                 else
00238                 {
00239                     xnOSMemSet(m_pAllocatedData, 0, DataSize());
00240                 }
00241             }
00242 
00243             return (XN_STATUS_OK);
00244         }
00245 
00246     protected:
00247         XnUInt8* m_pAllocatedData;
00248 
00249     private:
00250         XnOutputMetaData m_output;
00251 
00252         const XnUInt8** m_ppData;
00253         XnUInt32 m_nAllocatedSize;
00254     };
00255 
00260     class MapMetaData : public OutputMetaData
00261     {
00262     public:
00269         inline MapMetaData(XnPixelFormat format, const XnUInt8** ppData) : OutputMetaData(ppData)
00270         {
00271             xnOSMemSet(&m_map, 0, sizeof(XnMapMetaData));
00272             m_map.pOutput = OutputMetaData::GetUnderlying();
00273             m_map.PixelFormat = format;
00274         }
00275 
00277         inline XnUInt32 XRes() const { return m_map.Res.X; }
00279         inline XnUInt32& XRes() { return m_map.Res.X; }
00280 
00282         inline XnUInt32 YRes() const { return m_map.Res.Y; }
00284         inline XnUInt32& YRes() { return m_map.Res.Y; }
00285 
00287         inline XnUInt32 XOffset() const { return m_map.Offset.X; }
00289         inline XnUInt32& XOffset() { return m_map.Offset.X; }
00290 
00292         inline XnUInt32 YOffset() const { return m_map.Offset.Y; }
00294         inline XnUInt32& YOffset() { return m_map.Offset.Y; }
00295 
00297         inline XnUInt32 FullXRes() const { return m_map.FullRes.X; }
00299         inline XnUInt32& FullXRes() { return m_map.FullRes.X; }
00300 
00302         inline XnUInt32 FullYRes() const { return m_map.FullRes.Y; }
00304         inline XnUInt32& FullYRes() { return m_map.FullRes.Y; }
00305 
00307         inline XnUInt32 FPS() const { return m_map.nFPS; }
00309         inline XnUInt32& FPS() { return m_map.nFPS; }
00310 
00312         inline XnPixelFormat PixelFormat() const { return m_map.PixelFormat; }
00313 
00315         inline const XnMapMetaData* GetUnderlying() const { return &m_map; }
00317         inline XnMapMetaData* GetUnderlying() { return &m_map; }
00318 
00320         inline XnUInt32 BytesPerPixel() const
00321         {
00322             switch (PixelFormat())
00323             {
00324                 case XN_PIXEL_FORMAT_RGB24:
00325                     return sizeof(XnRGB24Pixel);
00326                 case XN_PIXEL_FORMAT_YUV422:
00327                     return sizeof(XnYUV422DoublePixel)/2;
00328                 case XN_PIXEL_FORMAT_GRAYSCALE_8_BIT:
00329                     return sizeof(XnGrayscale8Pixel);
00330                 case XN_PIXEL_FORMAT_GRAYSCALE_16_BIT:
00331                     return sizeof(XnGrayscale16Pixel);
00332                 case XN_PIXEL_FORMAT_MJPEG:
00333                     return 2;
00334                 default:
00335                     XN_ASSERT(FALSE);
00336                     return 0;
00337             }
00338         }
00339 
00346         XnStatus AllocateData(XnUInt32 nXRes, XnUInt32 nYRes)
00347         {
00348             XnStatus nRetVal = XN_STATUS_OK;
00349             
00350             XnUInt32 nSize = nXRes * nYRes * BytesPerPixel();
00351             nRetVal = OutputMetaData::AllocateData(nSize);
00352             XN_IS_STATUS_OK(nRetVal);
00353 
00354             FullXRes() = XRes() = nXRes;
00355             FullYRes() = YRes() = nYRes;
00356             XOffset() = YOffset() = 0;
00357             
00358             return (XN_STATUS_OK);
00359         }
00360 
00369         XnStatus ReAdjust(XnUInt32 nXRes, XnUInt32 nYRes, const XnUInt8* pExternalBuffer)
00370         {
00371             XnStatus nRetVal = XN_STATUS_OK;
00372 
00373             if (pExternalBuffer == NULL)
00374             {
00375                 nRetVal = AllocateData(nXRes, nYRes);
00376                 XN_IS_STATUS_OK(nRetVal);
00377             }
00378             else
00379             {
00380                 FullXRes() = XRes() = nXRes;
00381                 FullYRes() = YRes() = nYRes;
00382                 XOffset() = YOffset() = 0;
00383                 Data() = pExternalBuffer;
00384                 DataSize() = nXRes * nYRes * BytesPerPixel();
00385             }
00386 
00387             return (XN_STATUS_OK);
00388         }
00389 
00390     protected:
00391         XnPixelFormat& PixelFormatImpl() { return m_map.PixelFormat; }
00392 
00393     private:
00394         // block copy ctor and assignment operator
00395         MapMetaData& operator=(const MapMetaData&);
00396         inline MapMetaData(const MapMetaData& other);
00397 
00398         // Members
00399         XnMapMetaData m_map;
00400     };
00401 
00402 /* Declares a map data accessor class */
00403 #define _XN_DECLARE_MAP_DATA_CLASS(_name, _pixelType)                           \
00404     class _name                                                                 \
00405     {                                                                           \
00406     public:                                                                     \
00407         inline _name(_pixelType*& pData, XnUInt32& nXRes, XnUInt32 &nYRes) :    \
00408         m_pData(pData), m_nXRes(nXRes), m_nYRes(nYRes) {}                       \
00409                                                                                 \
00410         inline XnUInt32 XRes() const { return m_nXRes; }                        \
00411         inline XnUInt32 YRes() const { return m_nYRes; }                        \
00412                                                                                 \
00413         inline const _pixelType& operator[](XnUInt32 nIndex) const              \
00414         {                                                                       \
00415             XN_ASSERT(nIndex < (m_nXRes * m_nYRes));                            \
00416             return m_pData[nIndex];                                             \
00417         }                                                                       \
00418         inline _pixelType& operator[](XnUInt32 nIndex)                          \
00419         {                                                                       \
00420             XN_ASSERT(nIndex < (m_nXRes *m_nYRes));                             \
00421             return m_pData[nIndex];                                             \
00422         }                                                                       \
00423                                                                                 \
00424         inline const _pixelType& operator()(XnUInt32 x, XnUInt32 y) const       \
00425         {                                                                       \
00426             XN_ASSERT(x < m_nXRes && y < m_nYRes);                              \
00427             return m_pData[y*m_nXRes + x];                                      \
00428         }                                                                       \
00429         inline _pixelType& operator()(XnUInt32 x, XnUInt32 y)                   \
00430         {                                                                       \
00431             XN_ASSERT(x < m_nXRes && y < m_nYRes);                              \
00432             return m_pData[y*m_nXRes + x];                                      \
00433         }                                                                       \
00434                                                                                 \
00435     private:                                                                    \
00436         /* block copy ctor and assignment operator */                           \
00437         _name(const _name& other);                                              \
00438         _name& operator=(const _name&);                                         \
00439                                                                                 \
00440         _pixelType*& m_pData;                                                   \
00441         XnUInt32& m_nXRes;                                                      \
00442         XnUInt32& m_nYRes;                                                      \
00443     };                                                                      
00444 
00445     _XN_DECLARE_MAP_DATA_CLASS(DepthMap, XnDepthPixel);
00446     _XN_DECLARE_MAP_DATA_CLASS(ImageMap, XnUInt8);
00447     _XN_DECLARE_MAP_DATA_CLASS(RGB24Map, XnRGB24Pixel);
00448     _XN_DECLARE_MAP_DATA_CLASS(Grayscale16Map, XnGrayscale16Pixel);
00449     _XN_DECLARE_MAP_DATA_CLASS(Grayscale8Map, XnGrayscale8Pixel);
00450     _XN_DECLARE_MAP_DATA_CLASS(IRMap, XnIRPixel);
00451     _XN_DECLARE_MAP_DATA_CLASS(LabelMap, XnLabel);
00452 
00457     class DepthMetaData : public MapMetaData
00458     {
00459     public:
00463         inline DepthMetaData() : 
00464             MapMetaData(XN_PIXEL_FORMAT_GRAYSCALE_16_BIT, (const XnUInt8**)&m_depth.pData),
00465             m_depthMap(const_cast<XnDepthPixel*&>(m_depth.pData), MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y),
00466             m_writableDepthMap((XnDepthPixel*&)m_pAllocatedData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y)
00467         {
00468             xnOSMemSet(&m_depth, 0, sizeof(XnDepthMetaData));
00469             m_depth.pMap = MapMetaData::GetUnderlying();
00470         }
00471 
00477         inline void InitFrom(const DepthMetaData& other)
00478         {
00479             xnCopyDepthMetaData(&m_depth, &other.m_depth);
00480         }
00481 
00491         inline XnStatus InitFrom(const DepthMetaData& other, XnUInt32 nXRes, XnUInt32 nYRes, const XnDepthPixel* pExternalBuffer)
00492         {
00493             InitFrom(other);
00494             return ReAdjust(nXRes, nYRes, pExternalBuffer);
00495         }
00496 
00502         XnStatus CopyFrom(const DepthMetaData& other)
00503         {
00504             // copy props
00505             InitFrom(other);
00506             // and make a copy of the data (this will allocate and copy data)
00507             return MakeDataWritable();
00508         }
00509 
00511         XnStatus ReAdjust(XnUInt32 nXRes, XnUInt32 nYRes, const XnDepthPixel* pExternalBuffer = NULL)
00512         {
00513             return MapMetaData::ReAdjust(nXRes, nYRes, (const XnUInt8*)pExternalBuffer);
00514         }
00515 
00517         inline XnDepthPixel ZRes() const { return m_depth.nZRes; }
00519         inline XnDepthPixel& ZRes() { return m_depth.nZRes; }
00520 
00522         inline const XnDepthPixel* Data() const { return (const XnDepthPixel*)MapMetaData::Data(); }
00524         inline const XnDepthPixel*& Data() { return (const XnDepthPixel*&)MapMetaData::Data(); }
00526         inline XnDepthPixel* WritableData() { return (XnDepthPixel*)MapMetaData::WritableData(); }
00527 
00529         inline const xn::DepthMap& DepthMap() const { return m_depthMap; }
00531         inline xn::DepthMap& WritableDepthMap() 
00532         { 
00533             MakeDataWritable();
00534             return m_writableDepthMap; 
00535         }
00536 
00542         inline const XnDepthPixel& operator[](XnUInt32 nIndex) const 
00543         { 
00544             XN_ASSERT(nIndex < (XRes()*YRes()));
00545             return Data()[nIndex]; 
00546         }
00547 
00554         inline const XnDepthPixel& operator()(XnUInt32 x, XnUInt32 y) const 
00555         {
00556             XN_ASSERT(x < XRes() && y < YRes());
00557             return Data()[y*XRes() + x]; 
00558         }
00559 
00561         inline const XnDepthMetaData* GetUnderlying() const { return &m_depth; }
00563         inline XnDepthMetaData* GetUnderlying() { return &m_depth; }
00564 
00565     private:
00566         // block copy ctor and assignment operator (because we can't return errors in those)
00567         DepthMetaData(const DepthMetaData& other);
00568         DepthMetaData& operator=(const DepthMetaData&);
00569 
00570         XnDepthMetaData m_depth;
00571         const xn::DepthMap m_depthMap;
00572         xn::DepthMap m_writableDepthMap;
00573     };
00574 
00579     class ImageMetaData : public MapMetaData
00580     {
00581     public:
00583         inline ImageMetaData() : 
00584             MapMetaData(XN_PIXEL_FORMAT_RGB24, &m_image.pData),
00585             m_imageMap(const_cast<XnUInt8*&>(m_image.pData), MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y),
00586             m_writableImageMap((XnUInt8*&)m_pAllocatedData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y),
00587             m_rgb24Map((XnRGB24Pixel*&)m_image.pData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y),
00588             m_writableRgb24Map((XnRGB24Pixel*&)m_pAllocatedData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y),
00589             m_gray16Map((XnGrayscale16Pixel*&)m_image.pData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y),
00590             m_writableGray16Map((XnGrayscale16Pixel*&)m_pAllocatedData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y),
00591             m_gray8Map((XnGrayscale8Pixel*&)m_image.pData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y),
00592             m_writableGray8Map((XnGrayscale8Pixel*&)m_pAllocatedData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y)
00593         {
00594             xnOSMemSet(&m_image, 0, sizeof(XnImageMetaData));
00595             m_image.pMap = MapMetaData::GetUnderlying();
00596         }
00597 
00603         inline void InitFrom(const ImageMetaData& other)
00604         {
00605             xnCopyImageMetaData(&m_image, &other.m_image);
00606         }
00607 
00618         inline XnStatus InitFrom(const ImageMetaData& other, XnUInt32 nXRes, XnUInt32 nYRes, XnPixelFormat format, const XnUInt8* pExternalBuffer)
00619         {
00620             InitFrom(other);
00621             XnStatus nRetVal = ReAdjust(nXRes, nYRes, format, pExternalBuffer);
00622             XN_IS_STATUS_OK(nRetVal);
00623             PixelFormat() = format;
00624             return XN_STATUS_OK;
00625         }
00626 
00634         inline XnStatus AllocateData(XnUInt32 nXRes, XnUInt32 nYRes, XnPixelFormat format)
00635         {
00636             XnPixelFormat origFormat = PixelFormat();
00637             PixelFormat() = format;
00638             XnStatus nRetVal = MapMetaData::AllocateData(nXRes, nYRes);
00639             if (nRetVal != XN_STATUS_OK)
00640             {
00641                 PixelFormat() = origFormat;
00642                 return (nRetVal);
00643             }
00644 
00645             return XN_STATUS_OK;
00646         }
00647 
00649         inline XnStatus CopyFrom(const ImageMetaData& other)
00650         {
00651             // copy props
00652             xnCopyImageMetaData(&m_image, &other.m_image);
00653             // and make a copy of the data (this will allocate and copy data)
00654             return MakeDataWritable();
00655         }
00656 
00666         XnStatus ReAdjust(XnUInt32 nXRes, XnUInt32 nYRes, XnPixelFormat format, const XnUInt8* pExternalBuffer = NULL)
00667         {
00668             XnPixelFormat origFormat = PixelFormat();
00669             PixelFormat() = format;
00670             XnStatus nRetVal = MapMetaData::ReAdjust(nXRes, nYRes, pExternalBuffer);
00671             if (nRetVal != XN_STATUS_OK)
00672             {
00673                 PixelFormat() = origFormat;
00674                 return (nRetVal);
00675             }
00676 
00677             return XN_STATUS_OK;
00678         }
00679 
00681         inline XnPixelFormat PixelFormat() const { return MapMetaData::PixelFormat(); }
00683         inline XnPixelFormat& PixelFormat() { return MapMetaData::PixelFormatImpl(); }
00684 
00686         inline XnUInt8* WritableData() { return MapMetaData::WritableData(); }
00687 
00689         inline const XnRGB24Pixel* RGB24Data() const { return (const XnRGB24Pixel*)MapMetaData::Data(); }
00691         inline const XnRGB24Pixel*& RGB24Data() { return (const XnRGB24Pixel*&)MapMetaData::Data(); }
00693         inline XnRGB24Pixel* WritableRGB24Data() { return (XnRGB24Pixel*)MapMetaData::WritableData(); }
00694 
00696         inline const XnYUV422DoublePixel* YUV422Data() const { return (const XnYUV422DoublePixel*)MapMetaData::Data(); }
00698         inline const XnYUV422DoublePixel*& YUV422Data() { return (const XnYUV422DoublePixel*&)MapMetaData::Data(); }
00700         inline XnYUV422DoublePixel* WritableYUV422Data() { return (XnYUV422DoublePixel*)MapMetaData::WritableData(); }
00701 
00703         inline const XnGrayscale8Pixel* Grayscale8Data() const { return (const XnGrayscale8Pixel*)MapMetaData::Data(); }
00705         inline const XnGrayscale8Pixel*& Grayscale8Data() { return (const XnGrayscale8Pixel*&)MapMetaData::Data(); }
00707         inline XnGrayscale8Pixel* WritableGrayscale8Data() { return (XnGrayscale8Pixel*)MapMetaData::WritableData(); }
00708 
00710         inline const XnGrayscale16Pixel* Grayscale16Data() const { return (const XnGrayscale16Pixel*)MapMetaData::Data(); }
00712         inline const XnGrayscale16Pixel*& Grayscale16Data() { return (const XnGrayscale16Pixel*&)MapMetaData::Data(); }
00714         inline XnGrayscale16Pixel* WritableGrayscale16Data() { return (XnGrayscale16Pixel*)MapMetaData::WritableData(); }
00715 
00717         inline const xn::ImageMap& ImageMap() const { return m_imageMap; }
00719         inline xn::ImageMap& WritableImageMap() { MakeDataWritable(); return m_writableImageMap; }
00720 
00722         inline const xn::RGB24Map& RGB24Map() const { return m_rgb24Map; }
00724         inline xn::RGB24Map& WritableRGB24Map() { MakeDataWritable(); return m_writableRgb24Map; }
00725 
00727         inline const xn::Grayscale8Map& Grayscale8Map() const { return m_gray8Map; }
00729         inline xn::Grayscale8Map& WritableGrayscale8Map() { MakeDataWritable(); return m_writableGray8Map; }
00730 
00732         inline const xn::Grayscale16Map& Grayscale16Map() const { return m_gray16Map; }
00734         inline xn::Grayscale16Map& WritableGrayscale16Map() { MakeDataWritable(); return m_writableGray16Map; }
00735 
00737         inline const XnImageMetaData* GetUnderlying() const { return &m_image; }
00739         inline XnImageMetaData* GetUnderlying() { return &m_image; }
00740 
00741     private:
00742         // block copy ctor and assignment operator
00743         ImageMetaData(const ImageMetaData& other);
00744         ImageMetaData& operator=(const ImageMetaData&);
00745 
00746         XnImageMetaData m_image;
00747         const xn::ImageMap m_imageMap;
00748         xn::ImageMap m_writableImageMap;
00749         const xn::RGB24Map m_rgb24Map;
00750         xn::RGB24Map m_writableRgb24Map;
00751         const xn::Grayscale16Map m_gray16Map;
00752         xn::Grayscale16Map m_writableGray16Map;
00753         const xn::Grayscale8Map m_gray8Map;
00754         xn::Grayscale8Map m_writableGray8Map;
00755     };
00756 
00761     class IRMetaData : public MapMetaData
00762     {
00763     public:
00765         inline IRMetaData() : 
00766             MapMetaData(XN_PIXEL_FORMAT_GRAYSCALE_16_BIT, (const XnUInt8**)&m_ir.pData),
00767             m_irMap(const_cast<XnIRPixel*&>(m_ir.pData), MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y),
00768             m_writableIRMap((XnIRPixel*&)m_pAllocatedData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y)
00769         {
00770             xnOSMemSet(&m_ir, 0, sizeof(XnIRMetaData));
00771             m_ir.pMap = MapMetaData::GetUnderlying();
00772         }
00773 
00779         inline void InitFrom(const IRMetaData& other)
00780         {
00781             xnCopyIRMetaData(&m_ir, &other.m_ir);
00782         }
00783 
00785         inline XnStatus InitFrom(const IRMetaData& other, XnUInt32 nXRes, XnUInt32 nYRes, const XnIRPixel* pExternalBuffer)
00786         {
00787             InitFrom(other);
00788             return ReAdjust(nXRes, nYRes, pExternalBuffer);
00789         }
00790 
00792         XnStatus CopyFrom(const IRMetaData& other)
00793         {
00794             // copy props
00795             xnCopyIRMetaData(&m_ir, &other.m_ir);
00796             // and make a copy of the data (this will allocate and copy data)
00797             return MakeDataWritable();
00798         }
00799 
00801         XnStatus ReAdjust(XnUInt32 nXRes, XnUInt32 nYRes, const XnIRPixel* pExternalBuffer = NULL)
00802         {
00803             return MapMetaData::ReAdjust(nXRes, nYRes, (const XnUInt8*)pExternalBuffer);
00804         }
00805 
00807         inline const XnIRPixel* Data() const { return (const XnIRPixel*)MapMetaData::Data(); }
00809         inline const XnIRPixel*& Data() { return (const XnIRPixel*&)MapMetaData::Data(); }
00811         inline XnIRPixel* WritableData() { return (XnIRPixel*)MapMetaData::WritableData(); }
00812 
00818         inline const XnIRPixel& operator[](XnUInt32 nIndex) const 
00819         { 
00820             XN_ASSERT(nIndex < (XRes()*YRes()));
00821             return Data()[nIndex]; 
00822         }
00823 
00830         inline const XnIRPixel& operator()(XnUInt32 x, XnUInt32 y) const 
00831         {
00832             XN_ASSERT(x < XRes() && y < YRes());
00833             return Data()[y*XRes() + x]; 
00834         }
00835 
00837         inline const xn::IRMap& IRMap() const { return m_irMap; }
00839         inline xn::IRMap& WritableIRMap() { MakeDataWritable(); return m_writableIRMap; }
00840 
00842         inline const XnIRMetaData* GetUnderlying() const { return &m_ir; }
00844         inline XnIRMetaData* GetUnderlying() { return &m_ir; }
00845 
00846     private:
00847         // block copy ctor and assignment operator
00848         IRMetaData(const IRMetaData& other);
00849         IRMetaData& operator=(const IRMetaData&);
00850 
00851         XnIRMetaData m_ir;
00852         const xn::IRMap m_irMap;
00853         xn::IRMap m_writableIRMap;
00854     };
00855 
00860     class AudioMetaData : public OutputMetaData
00861     {
00862     public:
00864         inline AudioMetaData() : OutputMetaData(&m_audio.pData)
00865         {
00866             xnOSMemSet(&m_audio, 0, sizeof(XnAudioMetaData));
00867             m_audio.pOutput = OutputMetaData::GetUnderlying();
00868         }
00869 
00875         inline void InitFrom(const AudioMetaData& other)
00876         {
00877             xnCopyAudioMetaData(&m_audio, &other.m_audio);
00878         }
00879 
00881         inline XnUInt8 NumberOfChannels() const { return m_audio.Wave.nChannels; }
00883         inline XnUInt8& NumberOfChannels() { return m_audio.Wave.nChannels; }
00884 
00886         inline XnUInt32 SampleRate() const { return m_audio.Wave.nSampleRate; }
00888         inline XnUInt32& SampleRate() { return m_audio.Wave.nSampleRate; }
00889 
00891         inline XnUInt16 BitsPerSample() const { return m_audio.Wave.nBitsPerSample; }
00893         inline XnUInt16& BitsPerSample() { return m_audio.Wave.nBitsPerSample; }
00894 
00896         inline const XnAudioMetaData* GetUnderlying() const { return &m_audio; }
00898         inline XnAudioMetaData* GetUnderlying() { return &m_audio; }
00899 
00900     private:
00901         // block copy ctor and assignment operator
00902         AudioMetaData(const AudioMetaData& other);
00903         AudioMetaData& operator=(const AudioMetaData&);
00904 
00905         XnAudioMetaData m_audio;
00906         XnBool m_bAllocated;
00907     };
00908 
00913     class SceneMetaData : public MapMetaData
00914     {
00915     public:
00917         inline SceneMetaData() : 
00918             MapMetaData(XN_PIXEL_FORMAT_GRAYSCALE_16_BIT, (const XnUInt8**)&m_scene.pData),
00919             m_labelMap(const_cast<XnLabel*&>(m_scene.pData), MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y),
00920             m_writableLabelMap((XnLabel*&)m_pAllocatedData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y)
00921         {
00922             xnOSMemSet(&m_scene, 0, sizeof(XnSceneMetaData));
00923             m_scene.pMap = MapMetaData::GetUnderlying();
00924         }
00925 
00931         inline void InitFrom(const SceneMetaData& other)
00932         {
00933             xnCopySceneMetaData(&m_scene, &other.m_scene);
00934         }
00935 
00937         inline XnStatus InitFrom(const SceneMetaData& other, XnUInt32 nXRes, XnUInt32 nYRes, const XnLabel* pExternalBuffer)
00938         {
00939             InitFrom(other);
00940             return ReAdjust(nXRes, nYRes, pExternalBuffer);
00941         }
00942 
00944         XnStatus CopyFrom(const SceneMetaData& other)
00945         {
00946             // copy props
00947             xnCopySceneMetaData(&m_scene, &other.m_scene);
00948             // and make a copy of the data (this will allocate and copy data)
00949             return MakeDataWritable();
00950         }
00951 
00953         XnStatus ReAdjust(XnUInt32 nXRes, XnUInt32 nYRes, const XnLabel* pExternalBuffer = NULL)
00954         {
00955             return MapMetaData::ReAdjust(nXRes, nYRes, (const XnUInt8*)pExternalBuffer);
00956         }
00957 
00959         inline const XnLabel* Data() const { return (const XnLabel*)MapMetaData::Data(); }
00961         inline const XnLabel*& Data() { return (const XnLabel*&)MapMetaData::Data(); }
00963         inline XnLabel* WritableData() { return (XnLabel*)MapMetaData::WritableData(); }
00964 
00966         inline const xn::LabelMap& LabelMap() const { return m_labelMap; }
00968         inline xn::LabelMap& WritableLabelMap() { MakeDataWritable(); return m_writableLabelMap; }
00969 
00975         inline const XnLabel& operator[](XnUInt32 nIndex) const
00976         {
00977             XN_ASSERT(nIndex < (XRes()*YRes()));
00978             return Data()[nIndex];
00979         }
00980 
00987         inline const XnLabel& operator()(XnUInt32 x, XnUInt32 y) const
00988         {
00989             XN_ASSERT(x < XRes() && y < YRes());
00990             return (*this)[y*XRes() + x];
00991         }
00992 
00994         inline const XnSceneMetaData* GetUnderlying() const { return &m_scene; }
00996         inline XnSceneMetaData* GetUnderlying() { return &m_scene; }
00997 
00998     private:
00999         // block copy ctor and assignment operator
01000         SceneMetaData(const SceneMetaData& other);
01001         SceneMetaData& operator=(const SceneMetaData&);
01002 
01003         XnSceneMetaData m_scene;
01004         const xn::LabelMap m_labelMap;
01005         xn::LabelMap m_writableLabelMap;
01006     };
01007 
01008     //---------------------------------------------------------------------------
01009     // NodeWrapper
01010     //---------------------------------------------------------------------------
01011 
01016     class NodeWrapper
01017     {
01018     public:
01019         friend class Context;
01020 
01026         inline NodeWrapper(XnNodeHandle hNode) : m_hNode(NULL), m_hShuttingDownCallback(NULL)
01027         {
01028             NodeWrapper::SetHandle(hNode);
01029         }
01030 
01031         inline NodeWrapper(const NodeWrapper& other) : m_hNode(NULL), m_hShuttingDownCallback(NULL)
01032         {
01033             NodeWrapper::SetHandle(other.GetHandle());
01034         }
01035 
01036         inline NodeWrapper& operator=(const NodeWrapper& other)
01037         {
01038             NodeWrapper::SetHandle(other.GetHandle());
01039             return *this;
01040         }
01041 
01042         inline ~NodeWrapper()
01043         {
01044             NodeWrapper::SetHandle(NULL);
01045         }
01046 
01047         inline operator XnNodeHandle() const { return GetHandle(); }
01048 
01050         inline XnNodeHandle GetHandle() const { return m_hNode; }
01051 
01057         inline XnBool operator==(const NodeWrapper& other)
01058         {
01059             return (GetHandle() == other.GetHandle());
01060         }
01061 
01067         inline XnBool operator!=(const NodeWrapper& other)
01068         {
01069             return (GetHandle() != other.GetHandle());
01070         }
01071 
01073         inline XnBool IsValid() const { return (GetHandle() != NULL); }
01074         
01078         const XnChar* GetName() const {return xnGetNodeName(GetHandle()); }
01079 
01083         inline XnStatus AddRef() { return xnProductionNodeAddRef(GetHandle()); }
01084 
01088         inline void Release() 
01089         {
01090             NodeWrapper::SetHandle(NULL);
01091         }
01092 
01093         inline XnStatus XN_API_DEPRECATED("Please use AddRef() instead.") Ref() { return AddRef(); }
01094         inline void XN_API_DEPRECATED("Please use Release() instead.") Unref() { Release(); }
01095 
01097         inline void SetHandle(XnNodeHandle hNode) 
01098         { 
01099             if (m_hNode == hNode)
01100             {
01101                 // Optimization: do nothing
01102                 return;
01103             }
01104 
01105             // check currently held node. If we're holding a node, release it
01106             if (m_hNode != NULL)
01107             {
01108                 XnContext* pContext = xnGetRefContextFromNodeHandle(m_hNode);
01109                 xnContextUnregisterFromShutdown(pContext, m_hShuttingDownCallback);
01110                 xnContextRelease(pContext);
01111                 xnProductionNodeRelease(m_hNode);
01112             }
01113 
01114             // check new node handle, if it points to a node, add ref to it
01115             if (hNode != NULL)
01116             {
01117                 XnStatus nRetVal = xnProductionNodeAddRef(hNode);
01118                 XN_ASSERT(nRetVal == XN_STATUS_OK);
01119 
01120                 XnContext* pContext = xnGetRefContextFromNodeHandle(hNode);
01121 
01122                 nRetVal = xnContextRegisterForShutdown(pContext, ContextShuttingDownCallback, this, &m_hShuttingDownCallback);
01123                 XN_ASSERT(nRetVal == XN_STATUS_OK);
01124 
01125                 xnContextRelease(pContext);
01126             }
01127 
01128             m_hNode = hNode; 
01129         }
01130 
01131         inline void TakeOwnership(XnNodeHandle hNode)
01132         {
01133             SetHandle(hNode);
01134 
01135             if (hNode != NULL)
01136             {
01137                 xnProductionNodeRelease(hNode);
01138             }
01139         }
01140 
01141     private:
01142         XnNodeHandle m_hNode;
01143         XnCallbackHandle m_hShuttingDownCallback;
01144 
01145         static void XN_CALLBACK_TYPE ContextShuttingDownCallback(XnContext* /*pContext*/, void* pCookie)
01146         {
01147             NodeWrapper* pThis = (NodeWrapper*)pCookie;
01148             pThis->m_hNode = NULL;
01149         }
01150     };
01151 
01152     //---------------------------------------------------------------------------
01153     // Node Info
01154     //---------------------------------------------------------------------------
01155 
01160     class NodeInfo
01161     {
01162     public:
01168         NodeInfo(XnNodeInfo* pInfo) : m_pNeededNodes(NULL), m_bOwnerOfNode(FALSE)
01169         {
01170             SetUnderlyingObject(pInfo);
01171         }
01172 
01178         NodeInfo(const NodeInfo& other) : m_pNeededNodes(NULL), m_bOwnerOfNode(FALSE)
01179         {
01180             SetUnderlyingObject(other.m_pInfo);
01181         }
01182 
01184         ~NodeInfo()
01185         {
01186             SetUnderlyingObject(NULL);
01187         }
01188 
01194         inline NodeInfo& operator=(const NodeInfo& other)
01195         {
01196             SetUnderlyingObject(other.m_pInfo);
01197             return *this;
01198         }
01199 
01201         inline operator XnNodeInfo*()
01202         {
01203             return m_pInfo;
01204         }
01205 
01209         inline XnStatus SetInstanceName(const XnChar* strName)
01210         {
01211             return xnNodeInfoSetInstanceName(m_pInfo, strName);
01212         }
01213 
01217         inline const XnProductionNodeDescription& GetDescription() const
01218         {
01219             return *xnNodeInfoGetDescription(m_pInfo);
01220         }
01221 
01225         inline const XnChar* GetInstanceName() const
01226         {
01227             return xnNodeInfoGetInstanceName(m_pInfo);
01228         }
01229 
01233         inline const XnChar* GetCreationInfo() const
01234         {
01235             return xnNodeInfoGetCreationInfo(m_pInfo);
01236         }
01237 
01241         inline NodeInfoList& GetNeededNodes() const;
01242 
01250         inline XnStatus GetInstance(ProductionNode& node) const;
01251 
01255         inline const void* GetAdditionalData() const
01256         {
01257             return xnNodeInfoGetAdditionalData(m_pInfo);
01258         }
01259 
01263         inline XnStatus GetTreeStringRepresentation(XnChar* csResultBuffer, XnUInt32 nBufferSize) const
01264         {
01265             return xnNodeInfoGetTreeStringRepresentation(m_pInfo, csResultBuffer, nBufferSize);
01266         }
01267 
01268     private:
01269         inline void SetUnderlyingObject(XnNodeInfo* pInfo);
01270 
01271         XnNodeInfo* m_pInfo;
01272         mutable NodeInfoList* m_pNeededNodes;
01273         XnBool m_bOwnerOfNode; // backwards compatibility
01274         friend class Context;
01275     };
01276 
01277     //---------------------------------------------------------------------------
01278     // Query
01279     //---------------------------------------------------------------------------
01280 
01286     class Query
01287     {
01288     public:
01290         inline Query() : m_bAllocated(TRUE)
01291         {
01292             xnNodeQueryAllocate(&m_pQuery);
01293         }
01294 
01295         inline Query(XnNodeQuery* pNodeQuery) : m_bAllocated(FALSE), m_pQuery(pNodeQuery)
01296         {
01297         }
01298 
01300         ~Query()
01301         {
01302             if (m_bAllocated)
01303             {
01304                 xnNodeQueryFree(m_pQuery);
01305             }
01306         }
01307 
01309         inline const XnNodeQuery* GetUnderlyingObject() const { return m_pQuery; }
01310         inline XnNodeQuery* GetUnderlyingObject() { return m_pQuery; }
01311 
01315         inline XnStatus SetVendor(const XnChar* strVendor)
01316         {
01317             return xnNodeQuerySetVendor(m_pQuery, strVendor);
01318         }
01319 
01323         inline XnStatus SetName(const XnChar* strName)
01324         {
01325             return xnNodeQuerySetName(m_pQuery, strName);
01326         }
01327 
01331         inline XnStatus SetMinVersion(const XnVersion& minVersion)
01332         {
01333             return xnNodeQuerySetMinVersion(m_pQuery, &minVersion);
01334         }
01335 
01339         inline XnStatus SetMaxVersion(const XnVersion& maxVersion)
01340         {
01341             return xnNodeQuerySetMaxVersion(m_pQuery, &maxVersion);
01342         }
01343 
01347         inline XnStatus AddSupportedCapability(const XnChar* strNeededCapability)
01348         {
01349             return xnNodeQueryAddSupportedCapability(m_pQuery, strNeededCapability);
01350         }
01351 
01355         inline XnStatus AddSupportedMapOutputMode(const XnMapOutputMode& MapOutputMode)
01356         {
01357             return xnNodeQueryAddSupportedMapOutputMode(m_pQuery, &MapOutputMode);
01358         }
01359 
01363         inline XnStatus SetSupportedMinUserPositions(const XnUInt32 nCount)
01364         {
01365             return xnNodeQuerySetSupportedMinUserPositions(m_pQuery, nCount);
01366         }
01367 
01371         inline XnStatus SetExistingNodeOnly(XnBool bExistingNode)
01372         {
01373             return xnNodeQuerySetExistingNodeOnly(m_pQuery, bExistingNode);
01374         }
01375 
01379         inline XnStatus AddNeededNode(const XnChar* strInstanceName)
01380         {
01381             return xnNodeQueryAddNeededNode(m_pQuery, strInstanceName);
01382         }
01383 
01387         inline XnStatus SetCreationInfo(const XnChar* strCreationInfo)
01388         {
01389             return xnNodeQuerySetCreationInfo(m_pQuery, strCreationInfo);
01390         }
01391 
01392     private:
01393         XnNodeQuery* m_pQuery;
01394         XnBool m_bAllocated;
01395     };
01396 
01397     //---------------------------------------------------------------------------
01398     // Node Info List
01399     //---------------------------------------------------------------------------
01400 
01405     class NodeInfoList
01406     {
01407     public:
01409         class Iterator
01410         {
01411         public:
01412             friend class NodeInfoList;
01413 
01419             XnBool operator==(const Iterator& other) const
01420             {
01421                 return m_it.pCurrent == other.m_it.pCurrent;
01422             }
01423 
01429             XnBool operator!=(const Iterator& other) const
01430             {
01431                 return m_it.pCurrent != other.m_it.pCurrent;
01432             }
01433 
01438             inline Iterator& operator++()
01439             {
01440                 UpdateInternalObject(xnNodeInfoListGetNext(m_it));
01441                 return *this;
01442             }
01443 
01448             inline Iterator operator++(int)
01449             {
01450                 XnNodeInfoListIterator curr = m_it;
01451                 UpdateInternalObject(xnNodeInfoListGetNext(m_it));
01452                 return Iterator(curr);
01453             }
01454 
01458             inline Iterator& operator--()
01459             {
01460                 UpdateInternalObject(xnNodeInfoListGetPrevious(m_it));
01461                 return *this;
01462             }
01463 
01467             inline Iterator operator--(int)
01468             {
01469                 XnNodeInfoListIterator curr = m_it;
01470                 UpdateInternalObject(xnNodeInfoListGetPrevious(m_it));
01471                 return Iterator(curr);
01472             }
01473 
01475             inline NodeInfo operator*()
01476             {
01477                 return m_Info;
01478             }
01479 
01480         private:
01481             inline Iterator(XnNodeInfoListIterator it) : m_Info(NULL)
01482             {
01483                 UpdateInternalObject(it);
01484             }
01485 
01486             inline void UpdateInternalObject(XnNodeInfoListIterator it)
01487             {
01488                 m_it = it;
01489                 if (xnNodeInfoListIteratorIsValid(it))
01490                 {
01491                     XnNodeInfo* pInfo = xnNodeInfoListGetCurrent(it);
01492                     m_Info = NodeInfo(pInfo);
01493                 }
01494                 else
01495                 {
01496                     m_Info = NodeInfo(NULL);
01497                 }
01498             }
01499 
01500             NodeInfo m_Info;
01501             XnNodeInfoListIterator m_it;
01502         };
01503 
01507         inline NodeInfoList() 
01508         {
01509             xnNodeInfoListAllocate(&m_pList);
01510             m_bAllocated = TRUE;
01511         }
01512 
01519         inline NodeInfoList(XnNodeInfoList* pList) : m_pList(pList), m_bAllocated(FALSE) {}
01520 
01522         inline ~NodeInfoList()
01523         {
01524             FreeImpl();
01525         }
01526 
01528         inline XnNodeInfoList* GetUnderlyingObject() const { return m_pList; }
01529 
01536         inline void ReplaceUnderlyingObject(XnNodeInfoList* pList) 
01537         {
01538             FreeImpl();
01539             m_pList = pList;
01540             m_bAllocated = TRUE;
01541         }
01542 
01546         inline XnStatus Add(XnProductionNodeDescription& description, const XnChar* strCreationInfo, NodeInfoList* pNeededNodes)
01547         {
01548             XnNodeInfoList* pList = (pNeededNodes == NULL) ? NULL : pNeededNodes->GetUnderlyingObject();
01549             return xnNodeInfoListAdd(m_pList, &description, strCreationInfo, pList);
01550         }
01551 
01555         inline XnStatus AddEx(XnProductionNodeDescription& description, const XnChar* strCreationInfo, NodeInfoList* pNeededNodes, const void* pAdditionalData, XnFreeHandler pFreeHandler)
01556         {
01557             XnNodeInfoList* pList = (pNeededNodes == NULL) ? NULL : pNeededNodes->GetUnderlyingObject();
01558             return xnNodeInfoListAddEx(m_pList, &description, strCreationInfo, pList, pAdditionalData, pFreeHandler);
01559         }
01560 
01564         inline XnStatus AddNode(NodeInfo& info)
01565         {
01566             return xnNodeInfoListAddNode(m_pList, info);
01567         }
01568 
01572         inline XnStatus AddNodeFromAnotherList(Iterator& it)
01573         {
01574             return xnNodeInfoListAddNodeFromList(m_pList, it.m_it);
01575         }
01576 
01578         inline Iterator Begin() const
01579         {
01580             return Iterator(xnNodeInfoListGetFirst(m_pList));
01581         }
01582 
01584         inline Iterator End() const
01585         {
01586             XnNodeInfoListIterator it = { NULL };
01587             return Iterator(it);
01588         }
01589 
01591         inline Iterator RBegin() const
01592         {
01593             return Iterator(xnNodeInfoListGetLast(m_pList));
01594         }
01595 
01597         inline Iterator REnd() const
01598         {
01599             XnNodeInfoListIterator it = { NULL };
01600             return Iterator(it);
01601         }
01602 
01606         inline XnStatus Remove(Iterator& it)
01607         {
01608             return xnNodeInfoListRemove(m_pList, it.m_it);
01609         }
01610 
01614         inline XnStatus Clear()
01615         {
01616             return xnNodeInfoListClear(m_pList);
01617         }
01618 
01622         inline XnStatus Append(NodeInfoList& other)
01623         {
01624             return xnNodeInfoListAppend(m_pList, other.GetUnderlyingObject());
01625         }
01626 
01630         inline XnBool IsEmpty()
01631         {
01632             return xnNodeInfoListIsEmpty(m_pList);
01633         }
01634 
01638         inline XnStatus FilterList(Context& context, Query& query);
01639 
01640     private:
01641         inline void FreeImpl()
01642         {
01643             if (m_bAllocated)
01644             {
01645                 xnNodeInfoListFree(m_pList);
01646                 m_bAllocated = FALSE;
01647                 m_pList = NULL;
01648             }
01649         }
01650 
01651         XnNodeInfoList* m_pList;
01652         XnBool m_bAllocated;
01653     };
01654 
01655     //---------------------------------------------------------------------------
01656     // Production Nodes Functionality
01657     //---------------------------------------------------------------------------
01658 
01663     class Capability : public NodeWrapper
01664     {
01665     public:
01671         Capability(XnNodeHandle hNode) : NodeWrapper(hNode) {}
01672         Capability(const NodeWrapper& node) : NodeWrapper(node) {}
01673     };
01674 
01679     class ErrorStateCapability : public Capability
01680     {
01681     public:
01687         ErrorStateCapability(XnNodeHandle hNode) : Capability(hNode) {}
01688         ErrorStateCapability(const NodeWrapper& node) : Capability(node) {}
01689 
01693         inline XnStatus GetErrorState() const
01694         {
01695             return xnGetNodeErrorState(GetHandle());
01696         }
01697 
01701         inline XnStatus RegisterToErrorStateChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
01702         {
01703             return _RegisterToStateChange(xnRegisterToNodeErrorStateChange, GetHandle(), handler, pCookie, hCallback);
01704         }
01705 
01709         inline void UnregisterFromErrorStateChange(XnCallbackHandle hCallback)
01710         {
01711             _UnregisterFromStateChange(xnUnregisterFromNodeErrorStateChange, GetHandle(), hCallback);
01712         }
01713     };
01714 
01719     class GeneralIntCapability : public Capability
01720     {
01721     public:
01728         GeneralIntCapability(XnNodeHandle hNode, const XnChar* strCap) : Capability(hNode), m_strCap(strCap) {}
01729         GeneralIntCapability(const NodeWrapper& node) : Capability(node) {}
01730 
01734         inline void GetRange(XnInt32& nMin, XnInt32& nMax, XnInt32& nStep, XnInt32& nDefault, XnBool& bIsAutoSupported) const
01735         {
01736             xnGetGeneralIntRange(GetHandle(), m_strCap, &nMin, &nMax, &nStep, &nDefault, &bIsAutoSupported);
01737         }
01738 
01742         inline XnInt32 Get()
01743         {
01744             XnInt32 nValue;
01745             xnGetGeneralIntValue(GetHandle(), m_strCap, &nValue);
01746             return nValue;
01747         }
01748 
01752         inline XnStatus Set(XnInt32 nValue)
01753         {
01754             return xnSetGeneralIntValue(GetHandle(), m_strCap, nValue);
01755         }
01756 
01760         XnStatus RegisterToValueChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback);
01761 
01765         void UnregisterFromValueChange(XnCallbackHandle hCallback);
01766 
01767     private:
01768         const XnChar* m_strCap;
01769     };
01770 
01775     class ProductionNode : public NodeWrapper
01776     {
01777     public:
01783         inline ProductionNode(XnNodeHandle hNode = NULL) : NodeWrapper(hNode) {}
01784         inline ProductionNode(const NodeWrapper& other) : NodeWrapper(other) {}
01785 
01789         inline NodeInfo GetInfo() const { return NodeInfo(xnGetNodeInfo(GetHandle())); }
01790 
01794         inline XnStatus AddNeededNode(ProductionNode& needed)
01795         {
01796             return xnAddNeededNode(GetHandle(), needed.GetHandle());
01797         }
01798 
01802         inline XnStatus RemoveNeededNode(ProductionNode& needed)
01803         {
01804             return xnRemoveNeededNode(GetHandle(), needed.GetHandle());
01805         }
01806 
01810         inline void GetContext(Context& context) const;
01811 
01815         inline XnBool IsCapabilitySupported(const XnChar* strCapabilityName) const
01816         {
01817             return xnIsCapabilitySupported(GetHandle(), strCapabilityName);
01818         }
01819 
01823         inline XnStatus SetIntProperty(const XnChar* strName, XnUInt64 nValue)
01824         {
01825             return xnSetIntProperty(GetHandle(), strName, nValue);
01826         }
01827 
01831         inline XnStatus SetRealProperty(const XnChar* strName, XnDouble dValue)
01832         {
01833             return xnSetRealProperty(GetHandle(), strName, dValue);
01834         }
01835 
01839         inline XnStatus SetStringProperty(const XnChar* strName, const XnChar* strValue)
01840         {
01841             return xnSetStringProperty(GetHandle(), strName, strValue);
01842         }
01843 
01847         inline XnStatus SetGeneralProperty(const XnChar* strName, XnUInt32 nBufferSize, const void* pBuffer)
01848         {
01849             return xnSetGeneralProperty(GetHandle(), strName, nBufferSize, pBuffer);
01850         }
01851 
01855         inline XnStatus GetIntProperty(const XnChar* strName, XnUInt64& nValue) const
01856         {
01857             return xnGetIntProperty(GetHandle(), strName, &nValue);
01858         }
01859 
01863         inline XnStatus GetRealProperty(const XnChar* strName, XnDouble &dValue) const
01864         {
01865             return xnGetRealProperty(GetHandle(), strName, &dValue);
01866         }
01867 
01871         inline XnStatus GetStringProperty(const XnChar* strName, XnChar* csValue, XnUInt32 nBufSize) const
01872         {
01873             return xnGetStringProperty(GetHandle(), strName, csValue, nBufSize);
01874         }
01875 
01879         inline XnStatus GetGeneralProperty(const XnChar* strName, XnUInt32 nBufferSize, void* pBuffer) const
01880         {
01881             return xnGetGeneralProperty(GetHandle(), strName, nBufferSize, pBuffer);
01882         }
01883 
01887         inline XnStatus LockForChanges(XnLockHandle* phLock)
01888         {
01889             return xnLockNodeForChanges(GetHandle(), phLock);
01890         }
01891 
01895         inline void UnlockForChanges(XnLockHandle hLock)
01896         {
01897             xnUnlockNodeForChanges(GetHandle(), hLock);
01898         }
01899 
01903         inline XnStatus LockedNodeStartChanges(XnLockHandle hLock)
01904         {
01905             return xnLockedNodeStartChanges(GetHandle(), hLock);
01906         }
01907 
01911         inline void LockedNodeEndChanges(XnLockHandle hLock)
01912         {
01913             xnLockedNodeEndChanges(GetHandle(), hLock);
01914         }
01915 
01921         inline const ErrorStateCapability GetErrorStateCap() const
01922         {
01923             return ErrorStateCapability(GetHandle());
01924         }
01925 
01931         inline ErrorStateCapability GetErrorStateCap()
01932         {
01933             return ErrorStateCapability(GetHandle());
01934         }
01935 
01943         inline GeneralIntCapability GetGeneralIntCap(const XnChar* strCapability)
01944         {
01945             return GeneralIntCapability(GetHandle(), strCapability);
01946         }
01947     };
01948 
01953     class DeviceIdentificationCapability : public Capability
01954     {
01955     public:
01961         DeviceIdentificationCapability(XnNodeHandle hNode) : Capability(hNode) {}
01962         DeviceIdentificationCapability(const NodeWrapper& node) : Capability(node) {}
01963 
01967         inline XnStatus GetDeviceName(XnChar* strBuffer, XnUInt32 nBufferSize)
01968         {
01969             return xnGetDeviceName(GetHandle(), strBuffer, &nBufferSize);
01970         }
01971 
01975         inline XnStatus GetVendorSpecificData(XnChar* strBuffer, XnUInt32 nBufferSize)
01976         {
01977             return xnGetVendorSpecificData(GetHandle(), strBuffer, &nBufferSize);
01978         }
01979 
01983         inline XnStatus GetSerialNumber(XnChar* strBuffer, XnUInt32 nBufferSize)
01984         {
01985             return xnGetSerialNumber(GetHandle(), strBuffer, &nBufferSize);
01986         }
01987     };
01988 
01993     class Device : public ProductionNode
01994     {
01995     public:
02001         inline Device(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {}
02002         inline Device(const NodeWrapper& other) : ProductionNode(other) {}
02003 
02007         inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL);
02008 
02014         inline DeviceIdentificationCapability GetIdentificationCap()
02015         {
02016             return DeviceIdentificationCapability(GetHandle());
02017         }
02018     };
02019 
02024     class MirrorCapability : public Capability
02025     {
02026     public:
02032         inline MirrorCapability(XnNodeHandle hNode) : Capability(hNode) {}
02033         MirrorCapability(const NodeWrapper& node) : Capability(node) {}
02034 
02038         inline XnStatus SetMirror(XnBool bMirror)
02039         {
02040             return xnSetMirror(GetHandle(), bMirror);
02041         }
02042 
02046         inline XnBool IsMirrored() const
02047         {
02048             return xnIsMirrored(GetHandle());
02049         }
02050 
02054         inline XnStatus RegisterToMirrorChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
02055         {
02056             return _RegisterToStateChange(xnRegisterToMirrorChange, GetHandle(), handler, pCookie, hCallback);
02057         }
02058 
02062         inline void UnregisterFromMirrorChange(XnCallbackHandle hCallback)
02063         {
02064             _UnregisterFromStateChange(xnUnregisterFromMirrorChange, GetHandle(), hCallback);
02065         }
02066     };
02067 
02072     class AlternativeViewPointCapability : public Capability
02073     {
02074     public:
02080         inline AlternativeViewPointCapability(XnNodeHandle hNode) : Capability(hNode) {}
02081         AlternativeViewPointCapability(const NodeWrapper& node) : Capability(node) {}
02082 
02086         inline XnBool IsViewPointSupported(ProductionNode& otherNode) const
02087         {
02088             return xnIsViewPointSupported(GetHandle(), otherNode.GetHandle());
02089         }
02090 
02094         inline XnStatus SetViewPoint(ProductionNode& otherNode)
02095         {
02096             return xnSetViewPoint(GetHandle(), otherNode.GetHandle());
02097         }
02098 
02102         inline XnStatus ResetViewPoint()
02103         {
02104             return xnResetViewPoint(GetHandle());
02105         }
02106 
02110         inline XnBool IsViewPointAs(ProductionNode& otherNode) const
02111         {
02112             return xnIsViewPointAs(GetHandle(), otherNode.GetHandle());
02113         }
02114 
02118         inline XnStatus RegisterToViewPointChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
02119         {
02120             return _RegisterToStateChange(xnRegisterToViewPointChange, GetHandle(), handler, pCookie, hCallback);
02121         }
02122 
02126         inline void UnregisterFromViewPointChange(XnCallbackHandle hCallback)
02127         {
02128             _UnregisterFromStateChange(xnUnregisterFromViewPointChange, GetHandle(), hCallback);
02129         }
02130     };
02131 
02136     class FrameSyncCapability : public Capability
02137     {
02138     public:
02144         inline FrameSyncCapability(XnNodeHandle hNode) : Capability(hNode) {}
02145         FrameSyncCapability(const NodeWrapper& node) : Capability(node) {}
02146 
02150         inline XnBool CanFrameSyncWith(Generator& other) const;
02151 
02155         inline XnStatus FrameSyncWith(Generator& other);
02156 
02160         inline XnStatus StopFrameSyncWith(Generator& other);
02161 
02165         inline XnBool IsFrameSyncedWith(Generator& other) const;
02166 
02170         inline XnStatus RegisterToFrameSyncChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
02171         {
02172             return _RegisterToStateChange(xnRegisterToFrameSyncChange, GetHandle(), handler, pCookie, hCallback);
02173         }
02174 
02178         inline void UnregisterFromFrameSyncChange(XnCallbackHandle hCallback)
02179         {
02180             _UnregisterFromStateChange(xnUnregisterFromFrameSyncChange, GetHandle(), hCallback);
02181         }
02182     };
02183 
02188     class Generator : public ProductionNode
02189     {
02190     public:
02196         inline Generator(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {}
02197         inline Generator(const NodeWrapper& other) : ProductionNode(other) {}
02198 
02202         inline XnStatus StartGenerating()
02203         {
02204             return xnStartGenerating(GetHandle());
02205         }
02206 
02210         inline XnBool IsGenerating() const
02211         {
02212             return xnIsGenerating(GetHandle());
02213         }
02214 
02218         inline XnStatus StopGenerating()
02219         {
02220             return xnStopGenerating(GetHandle());
02221         }
02222 
02226         inline XnStatus RegisterToGenerationRunningChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle &hCallback)
02227         {
02228             return _RegisterToStateChange(xnRegisterToGenerationRunningChange, GetHandle(), handler, pCookie, hCallback);
02229         }
02230 
02234         inline void UnregisterFromGenerationRunningChange(XnCallbackHandle hCallback)
02235         {
02236             _UnregisterFromStateChange(xnUnregisterFromGenerationRunningChange, GetHandle(), hCallback);
02237         }
02238 
02242         inline XnStatus RegisterToNewDataAvailable(StateChangedHandler handler, void* pCookie, XnCallbackHandle &hCallback)
02243         {
02244             return _RegisterToStateChange(xnRegisterToNewDataAvailable, GetHandle(), handler, pCookie, hCallback);
02245         }
02246 
02250         inline void UnregisterFromNewDataAvailable(XnCallbackHandle hCallback)
02251         {
02252             _UnregisterFromStateChange(xnUnregisterFromNewDataAvailable, GetHandle(), hCallback);
02253         }
02254 
02258         inline XnBool IsNewDataAvailable(XnUInt64* pnTimestamp = NULL) const
02259         {
02260             return xnIsNewDataAvailable(GetHandle(), pnTimestamp);
02261         }
02262 
02266         inline XnStatus WaitAndUpdateData()
02267         {
02268             return xnWaitAndUpdateData(GetHandle());
02269         }
02270 
02274         inline XnBool IsDataNew() const
02275         {
02276             return xnIsDataNew(GetHandle());
02277         }
02278 
02282         inline const void* GetData()
02283         {
02284             return xnGetData(GetHandle());
02285         }
02286         
02290         inline XnUInt32 GetDataSize() const
02291         {
02292             return xnGetDataSize(GetHandle());
02293         }
02294 
02298         inline XnUInt64 GetTimestamp() const
02299         {
02300             return xnGetTimestamp(GetHandle());
02301         }
02302 
02306         inline XnUInt32 GetFrameID() const
02307         {
02308             return xnGetFrameID(GetHandle());
02309         }
02310 
02316         inline const MirrorCapability GetMirrorCap() const
02317         { 
02318             return MirrorCapability(GetHandle()); 
02319         }
02320 
02326         inline MirrorCapability GetMirrorCap()
02327         { 
02328             return MirrorCapability(GetHandle()); 
02329         }
02330 
02336         inline const AlternativeViewPointCapability GetAlternativeViewPointCap() const
02337         { 
02338             return AlternativeViewPointCapability(GetHandle()); 
02339         }
02340 
02346         inline AlternativeViewPointCapability GetAlternativeViewPointCap()
02347         { 
02348             return AlternativeViewPointCapability(GetHandle()); 
02349         }
02350 
02356         inline const FrameSyncCapability GetFrameSyncCap() const
02357         {
02358             return FrameSyncCapability(GetHandle());
02359         }
02360 
02366         inline FrameSyncCapability GetFrameSyncCap()
02367         {
02368             return FrameSyncCapability(GetHandle());
02369         }
02370     };
02371 
02376     class Recorder : public ProductionNode
02377     {
02378     public:
02384         inline Recorder(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {}
02385         inline Recorder(const NodeWrapper& other) : ProductionNode(other) {}
02386 
02390         inline XnStatus Create(Context& context, const XnChar* strFormatName = NULL);
02391 
02395         inline XnStatus SetDestination(XnRecordMedium destType, const XnChar* strDest)
02396         {
02397             return xnSetRecorderDestination(GetHandle(), destType, strDest);
02398         }
02399 
02400         inline XnStatus GetDestination(XnRecordMedium& destType, XnChar* strDest, XnUInt32 nBufSize)
02401         {
02402             return xnGetRecorderDestination(GetHandle(), &destType, strDest, nBufSize);
02403         }
02404 
02408         inline XnStatus AddNodeToRecording(ProductionNode& Node, XnCodecID compression = XN_CODEC_NULL)
02409         {
02410             return xnAddNodeToRecording(GetHandle(), Node.GetHandle(), compression);
02411         }
02412 
02416         inline XnStatus RemoveNodeFromRecording(ProductionNode& Node)
02417         {
02418             return xnRemoveNodeFromRecording(GetHandle(), Node.GetHandle());
02419         }
02420 
02424         inline XnStatus Record()
02425         {
02426             return xnRecord(GetHandle());
02427         }
02428     };
02429 
02434     class Player : public ProductionNode
02435     {
02436     public:
02442         inline Player(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {}
02443         inline Player(const NodeWrapper& other) : ProductionNode(other) {}
02444 
02448         inline XnStatus Create(Context& context, const XnChar* strFormatName);
02449 
02453         inline XnStatus SetRepeat(XnBool bRepeat)
02454         {
02455             return xnSetPlayerRepeat(GetHandle(), bRepeat);
02456         }
02457 
02461         inline XnStatus SetSource(XnRecordMedium sourceType, const XnChar* strSource)
02462         {
02463             return xnSetPlayerSource(GetHandle(), sourceType, strSource);
02464         }
02465 
02469         inline XnStatus GetSource(XnRecordMedium &sourceType, XnChar* strSource, XnUInt32 nBufSize) const
02470         {
02471             return xnGetPlayerSource(GetHandle(), &sourceType, strSource, nBufSize);
02472         }
02473 
02477         inline XnStatus ReadNext()
02478         {
02479             return xnPlayerReadNext(GetHandle());
02480         }
02481 
02485         inline XnStatus SeekToTimeStamp(XnInt64 nTimeOffset, XnPlayerSeekOrigin origin)
02486         {
02487             return xnSeekPlayerToTimeStamp(GetHandle(), nTimeOffset, origin);
02488         }
02489 
02493         inline XnStatus SeekToFrame(const XnChar* strNodeName, XnInt32 nFrameOffset, XnPlayerSeekOrigin origin)
02494         {
02495             return xnSeekPlayerToFrame(GetHandle(), strNodeName, nFrameOffset, origin);
02496         }
02497 
02501         inline XnStatus TellTimestamp(XnUInt64& nTimestamp) const
02502         {
02503             return xnTellPlayerTimestamp(GetHandle(), &nTimestamp);
02504         }
02505 
02509         inline XnStatus TellFrame(const XnChar* strNodeName, XnUInt32& nFrame) const
02510         {
02511             return xnTellPlayerFrame(GetHandle(), strNodeName, &nFrame);
02512         }
02513 
02517         inline XnStatus GetNumFrames(const XnChar* strNodeName, XnUInt32& nFrames) const
02518         {
02519             return xnGetPlayerNumFrames(GetHandle(), strNodeName, &nFrames);
02520         }
02521 
02525         inline const XnChar* GetSupportedFormat() const
02526         {
02527             return xnGetPlayerSupportedFormat(GetHandle());
02528         }
02529 
02533         inline XnStatus EnumerateNodes(NodeInfoList& list) const
02534         {
02535             XnNodeInfoList* pList;
02536             XnStatus nRetVal = xnEnumeratePlayerNodes(GetHandle(), &pList);
02537             XN_IS_STATUS_OK(nRetVal);
02538 
02539             list.ReplaceUnderlyingObject(pList);
02540 
02541             return (XN_STATUS_OK);
02542         }
02543 
02547         inline XnBool IsEOF() const
02548         {
02549             return xnIsPlayerAtEOF(GetHandle());
02550         }
02551 
02555         inline XnStatus RegisterToEndOfFileReached(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
02556         {
02557             return _RegisterToStateChange(xnRegisterToEndOfFileReached, GetHandle(), handler, pCookie, hCallback);
02558         }
02559 
02563         inline void UnregisterFromEndOfFileReached(XnCallbackHandle hCallback)
02564         {
02565             _UnregisterFromStateChange(xnUnregisterFromEndOfFileReached, GetHandle(), hCallback);
02566         }
02567 
02571         inline XnStatus SetPlaybackSpeed(XnDouble dSpeed)
02572         {
02573             return xnSetPlaybackSpeed(GetHandle(), dSpeed);
02574         }
02575 
02579         inline XnDouble GetPlaybackSpeed() const
02580         {
02581             return xnGetPlaybackSpeed(GetHandle());
02582         }
02583     };
02584 
02589     class CroppingCapability : public Capability
02590     {
02591     public:
02597         inline CroppingCapability(XnNodeHandle hNode) : Capability(hNode) {}
02598         CroppingCapability(const NodeWrapper& node) : Capability(node) {}
02599 
02603         inline XnStatus SetCropping(const XnCropping& Cropping)
02604         {
02605             return xnSetCropping(GetHandle(), &Cropping);
02606         }
02607 
02611         inline XnStatus GetCropping(XnCropping& Cropping) const
02612         {
02613             return xnGetCropping(GetHandle(), &Cropping);
02614         }
02615 
02619         inline XnStatus RegisterToCroppingChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
02620         {
02621             return _RegisterToStateChange(xnRegisterToCroppingChange, GetHandle(), handler, pCookie, hCallback);
02622         }
02623 
02627         inline void UnregisterFromCroppingChange(XnCallbackHandle hCallback)
02628         {
02629             _UnregisterFromStateChange(xnUnregisterFromCroppingChange, GetHandle(), hCallback);
02630         }
02631     };
02632 
02637     class AntiFlickerCapability : public Capability
02638     {
02639     public:
02645         inline AntiFlickerCapability(XnNodeHandle hNode) : Capability(hNode) {}
02646         AntiFlickerCapability(const NodeWrapper& node) : Capability(node) {}
02647 
02651         inline XnStatus SetPowerLineFrequency(XnPowerLineFrequency nFrequency)
02652         {
02653             return xnSetPowerLineFrequency(GetHandle(), nFrequency);
02654         }
02655 
02659         inline XnPowerLineFrequency GetPowerLineFrequency()
02660         {
02661             return xnGetPowerLineFrequency(GetHandle());
02662         }
02663 
02667         inline XnStatus RegisterToPowerLineFrequencyChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
02668         {
02669             return _RegisterToStateChange(xnRegisterToPowerLineFrequencyChange, GetHandle(), handler, pCookie, hCallback);
02670         }
02671 
02675         inline void UnregisterFromPowerLineFrequencyChange(XnCallbackHandle hCallback)
02676         {
02677             _UnregisterFromStateChange(xnUnregisterFromPowerLineFrequencyChange, GetHandle(), hCallback);
02678         }
02679     };
02680 
02685     class MapGenerator : public Generator
02686     {
02687     public:
02693         inline MapGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {}
02694         inline MapGenerator(const NodeWrapper& other) : Generator(other) {}
02695 
02699         inline XnUInt32 GetSupportedMapOutputModesCount() const
02700         {
02701             return xnGetSupportedMapOutputModesCount(GetHandle());
02702         }
02703 
02707         inline XnStatus GetSupportedMapOutputModes(XnMapOutputMode* aModes, XnUInt32& nCount) const
02708         {
02709             return xnGetSupportedMapOutputModes(GetHandle(), aModes, &nCount);
02710         }
02711 
02715         inline XnStatus SetMapOutputMode(const XnMapOutputMode& OutputMode)
02716         {
02717             return xnSetMapOutputMode(GetHandle(), &OutputMode);
02718         }
02719 
02723         inline XnStatus GetMapOutputMode(XnMapOutputMode &OutputMode) const
02724         {
02725             return xnGetMapOutputMode(GetHandle(), &OutputMode);
02726         }
02727 
02731         inline XnUInt32 GetBytesPerPixel() const
02732         {
02733             return xnGetBytesPerPixel(GetHandle());
02734         }
02735 
02739         inline XnStatus RegisterToMapOutputModeChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
02740         {
02741             return _RegisterToStateChange(xnRegisterToMapOutputModeChange, GetHandle(), handler, pCookie, hCallback);
02742         }
02743 
02747         inline void UnregisterFromMapOutputModeChange(XnCallbackHandle hCallback)
02748         {
02749             _UnregisterFromStateChange(xnUnregisterFromMapOutputModeChange, GetHandle(), hCallback);
02750         }
02751 
02757         inline const CroppingCapability GetCroppingCap() const
02758         {
02759             return CroppingCapability(GetHandle());
02760         }
02761 
02767         inline CroppingCapability GetCroppingCap()
02768         {
02769             return CroppingCapability(GetHandle());
02770         }
02771 
02777         inline GeneralIntCapability GetBrightnessCap()
02778         {
02779             return GeneralIntCapability(GetHandle(), XN_CAPABILITY_BRIGHTNESS);
02780         }
02781 
02787         inline GeneralIntCapability GetContrastCap()
02788         {
02789             return GeneralIntCapability(GetHandle(), XN_CAPABILITY_CONTRAST);
02790         }
02791 
02797         inline GeneralIntCapability GetHueCap()
02798         {
02799             return GeneralIntCapability(GetHandle(), XN_CAPABILITY_HUE);
02800         }
02801 
02807         inline GeneralIntCapability GetSaturationCap()
02808         {
02809             return GeneralIntCapability(GetHandle(), XN_CAPABILITY_SATURATION);
02810         }
02811 
02817         inline GeneralIntCapability GetSharpnessCap()
02818         {
02819             return GeneralIntCapability(GetHandle(), XN_CAPABILITY_SHARPNESS);
02820         }
02821 
02827         inline GeneralIntCapability GetGammaCap()
02828         {
02829             return GeneralIntCapability(GetHandle(), XN_CAPABILITY_GAMMA);
02830         }
02831 
02837         inline GeneralIntCapability GetWhiteBalanceCap()
02838         {
02839             return GeneralIntCapability(GetHandle(), XN_CAPABILITY_COLOR_TEMPERATURE);
02840         }
02841 
02847         inline GeneralIntCapability GetBacklightCompensationCap()
02848         {
02849             return GeneralIntCapability(GetHandle(), XN_CAPABILITY_BACKLIGHT_COMPENSATION);
02850         }
02851 
02857         inline GeneralIntCapability GetGainCap()
02858         {
02859             return GeneralIntCapability(GetHandle(), XN_CAPABILITY_GAIN);
02860         }
02861 
02867         inline GeneralIntCapability GetPanCap()
02868         {
02869             return GeneralIntCapability(GetHandle(), XN_CAPABILITY_PAN);
02870         }
02871 
02877         inline GeneralIntCapability GetTiltCap()
02878         {
02879             return GeneralIntCapability(GetHandle(), XN_CAPABILITY_TILT);
02880         }
02881 
02887         inline GeneralIntCapability GetRollCap()
02888         {
02889             return GeneralIntCapability(GetHandle(), XN_CAPABILITY_ROLL);
02890         }
02891 
02897         inline GeneralIntCapability GetZoomCap()
02898         {
02899             return GeneralIntCapability(GetHandle(), XN_CAPABILITY_ZOOM);
02900         }
02901 
02907         inline GeneralIntCapability GetExposureCap()
02908         {
02909             return GeneralIntCapability(GetHandle(), XN_CAPABILITY_EXPOSURE);
02910         }
02911 
02917         inline GeneralIntCapability GetIrisCap()
02918         {
02919             return GeneralIntCapability(GetHandle(), XN_CAPABILITY_IRIS);
02920         }
02921 
02927         inline GeneralIntCapability GetFocusCap()
02928         {
02929             return GeneralIntCapability(GetHandle(), XN_CAPABILITY_FOCUS);
02930         }
02931 
02937         inline GeneralIntCapability GetLowLightCompensationCap()
02938         {
02939             return GeneralIntCapability(GetHandle(), XN_CAPABILITY_LOW_LIGHT_COMPENSATION);
02940         }
02941 
02947         inline AntiFlickerCapability GetAntiFlickerCap()
02948         {
02949             return AntiFlickerCapability(GetHandle());
02950         }
02951     };
02952 
02957     class UserPositionCapability : public Capability
02958     {
02959     public:
02965         inline UserPositionCapability(XnNodeHandle hNode = NULL) : Capability(hNode) {}
02966         UserPositionCapability(const NodeWrapper& node) : Capability(node) {}
02967 
02971         inline XnUInt32 GetSupportedUserPositionsCount() const
02972         {
02973             return xnGetSupportedUserPositionsCount(GetHandle());
02974         }
02975 
02979         inline XnStatus SetUserPosition(XnUInt32 nIndex, const XnBoundingBox3D& Position)
02980         {
02981             return xnSetUserPosition(GetHandle(), nIndex, &Position);
02982         }
02983 
02987         inline XnStatus GetUserPosition(XnUInt32 nIndex, XnBoundingBox3D& Position) const
02988         {
02989             return xnGetUserPosition(GetHandle(), nIndex, &Position);
02990         }
02991 
02995         inline XnStatus RegisterToUserPositionChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
02996         {
02997             return _RegisterToStateChange(xnRegisterToUserPositionChange, GetHandle(), handler, pCookie, hCallback);
02998         }
02999 
03003         inline void UnregisterFromUserPositionChange(XnCallbackHandle hCallback)
03004         {
03005             _UnregisterFromStateChange(xnUnregisterFromUserPositionChange, GetHandle(), hCallback);
03006         }
03007     };
03008 
03013     class DepthGenerator : public MapGenerator
03014     {
03015     public:
03021         inline DepthGenerator(XnNodeHandle hNode = NULL) : MapGenerator(hNode) {}
03022         inline DepthGenerator(const NodeWrapper& other) : MapGenerator(other) {}
03023 
03027         inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL);
03028 
03032         inline void GetMetaData(DepthMetaData& metaData) const 
03033         {
03034             xnGetDepthMetaData(GetHandle(), metaData.GetUnderlying());
03035         }
03036 
03040         inline const XnDepthPixel* GetDepthMap() const
03041         {
03042             return xnGetDepthMap(GetHandle());
03043         }
03044 
03048         inline XnDepthPixel GetDeviceMaxDepth() const
03049         {
03050             return xnGetDeviceMaxDepth(GetHandle());
03051         }
03052 
03056         inline XnStatus GetFieldOfView(XnFieldOfView& FOV) const
03057         {
03058             return xnGetDepthFieldOfView(GetHandle(), &FOV);
03059         }
03060 
03064         inline XnStatus RegisterToFieldOfViewChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
03065         {
03066             return _RegisterToStateChange(xnRegisterToDepthFieldOfViewChange, GetHandle(), handler, pCookie, hCallback);
03067         }
03068 
03072         inline void UnregisterFromFieldOfViewChange(XnCallbackHandle hCallback)
03073         {
03074             _UnregisterFromStateChange(xnUnregisterFromDepthFieldOfViewChange, GetHandle(), hCallback);
03075         }
03076 
03080         inline XnStatus ConvertProjectiveToRealWorld(XnUInt32 nCount, const XnPoint3D aProjective[], XnPoint3D aRealWorld[]) const
03081         {
03082             return xnConvertProjectiveToRealWorld(GetHandle(), nCount, aProjective, aRealWorld);
03083         }
03084 
03088         inline XnStatus ConvertRealWorldToProjective(XnUInt32 nCount, const XnPoint3D aRealWorld[], XnPoint3D aProjective[]) const
03089         {
03090             return xnConvertRealWorldToProjective(GetHandle(), nCount, aRealWorld, aProjective);
03091         }
03092 
03098         inline const UserPositionCapability GetUserPositionCap() const
03099         {
03100             return UserPositionCapability(GetHandle());
03101         }
03102 
03108         inline UserPositionCapability GetUserPositionCap()
03109         {
03110             return UserPositionCapability(GetHandle());
03111         }
03112     };
03113 
03118     class MockDepthGenerator : public DepthGenerator
03119     {
03120     public:
03126         inline MockDepthGenerator(XnNodeHandle hNode = NULL) : DepthGenerator(hNode) {}
03127         inline MockDepthGenerator(const NodeWrapper& other) : DepthGenerator(other) {}
03128 
03135         XnStatus Create(Context& context, const XnChar* strName = NULL);
03136 
03143         XnStatus CreateBasedOn(DepthGenerator& other, const XnChar* strName = NULL);
03144 
03148         inline XnStatus SetData(XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize, const XnDepthPixel* pDepthMap)
03149         {
03150             return xnMockDepthSetData(GetHandle(), nFrameID, nTimestamp, nDataSize, pDepthMap);
03151         }
03152 
03160         inline XnStatus SetData(const DepthMetaData& depthMD, XnUInt32 nFrameID, XnUInt64 nTimestamp)
03161         {
03162             return SetData(nFrameID, nTimestamp, depthMD.DataSize(), depthMD.Data());
03163         }
03164 
03170         inline XnStatus SetData(const DepthMetaData& depthMD)
03171         {
03172             return SetData(depthMD, depthMD.FrameID(), depthMD.Timestamp());
03173         }
03174     };
03175 
03180     class ImageGenerator : public MapGenerator
03181     {
03182     public:
03188         inline ImageGenerator(XnNodeHandle hNode = NULL) : MapGenerator(hNode) {}
03189         inline ImageGenerator(const NodeWrapper& other) : MapGenerator(other) {}
03190 
03194         inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL);
03195 
03199         inline void GetMetaData(ImageMetaData& metaData) const 
03200         {
03201             xnGetImageMetaData(GetHandle(), metaData.GetUnderlying());
03202         }
03203 
03207         inline const XnRGB24Pixel* GetRGB24ImageMap() const
03208         {
03209             return xnGetRGB24ImageMap(GetHandle());
03210         }
03211 
03215         inline const XnYUV422DoublePixel* GetYUV422ImageMap() const
03216         {
03217             return xnGetYUV422ImageMap(GetHandle());
03218         }
03219 
03223         inline const XnGrayscale8Pixel* GetGrayscale8ImageMap() const
03224         {
03225             return xnGetGrayscale8ImageMap(GetHandle());
03226         }
03227 
03231         inline const XnGrayscale16Pixel* GetGrayscale16ImageMap() const
03232         {
03233             return xnGetGrayscale16ImageMap(GetHandle());
03234         }
03235 
03239         inline const XnUInt8* GetImageMap() const
03240         {
03241             return xnGetImageMap(GetHandle());
03242         }
03243 
03247         inline XnBool IsPixelFormatSupported(XnPixelFormat Format) const
03248         {
03249             return xnIsPixelFormatSupported(GetHandle(), Format);
03250         }
03251 
03255         inline XnStatus SetPixelFormat(XnPixelFormat Format)
03256         {
03257             return xnSetPixelFormat(GetHandle(), Format);
03258         }
03259 
03263         inline XnPixelFormat GetPixelFormat() const
03264         {
03265             return xnGetPixelFormat(GetHandle());
03266         }
03267 
03271         inline XnStatus RegisterToPixelFormatChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
03272         {
03273             return _RegisterToStateChange(xnRegisterToPixelFormatChange, GetHandle(), handler, pCookie, hCallback);
03274         }
03275 
03279         inline void UnregisterFromPixelFormatChange(XnCallbackHandle hCallback)
03280         {
03281             _UnregisterFromStateChange(xnUnregisterFromPixelFormatChange, GetHandle(), hCallback);
03282         }
03283     };
03284 
03289     class MockImageGenerator : public ImageGenerator
03290     {
03291     public:
03297         inline MockImageGenerator(XnNodeHandle hNode = NULL) : ImageGenerator(hNode) {}
03298         inline MockImageGenerator(const NodeWrapper& other) : ImageGenerator(other) {}
03299 
03306         XnStatus Create(Context& context, const XnChar* strName = NULL);
03307 
03314         XnStatus CreateBasedOn(ImageGenerator& other, const XnChar* strName = NULL);
03315 
03319         inline XnStatus SetData(XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize, const XnUInt8* pImageMap)
03320         {
03321             return xnMockImageSetData(GetHandle(), nFrameID, nTimestamp, nDataSize, pImageMap);
03322         }
03323 
03331         inline XnStatus SetData(const ImageMetaData& imageMD, XnUInt32 nFrameID, XnUInt64 nTimestamp)
03332         {
03333             return SetData(nFrameID, nTimestamp, imageMD.DataSize(), imageMD.Data());
03334         }
03335 
03341         inline XnStatus SetData(const ImageMetaData& imageMD)
03342         {
03343             return SetData(imageMD, imageMD.FrameID(), imageMD.Timestamp());
03344         }
03345     };
03346 
03351     class IRGenerator : public MapGenerator
03352     {
03353     public:
03359         inline IRGenerator(XnNodeHandle hNode = NULL) : MapGenerator(hNode) {}
03360         inline IRGenerator(const NodeWrapper& other) : MapGenerator(other) {}
03361 
03365         inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL);
03366 
03370         inline void GetMetaData(IRMetaData& metaData) const 
03371         { 
03372             xnGetIRMetaData(GetHandle(), metaData.GetUnderlying());
03373         }
03374 
03378         inline const XnIRPixel* GetIRMap() const
03379         {
03380             return xnGetIRMap(GetHandle());
03381         }
03382     };
03383 
03388     class MockIRGenerator : public IRGenerator
03389     {
03390     public:
03396         inline MockIRGenerator(XnNodeHandle hNode = NULL) : IRGenerator(hNode) {}
03397         inline MockIRGenerator(const NodeWrapper& other) : IRGenerator(other) {}
03398 
03405         XnStatus Create(Context& context, const XnChar* strName = NULL);
03412         XnStatus CreateBasedOn(IRGenerator& other, const XnChar* strName = NULL);
03413 
03417         inline XnStatus SetData(XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize, const XnIRPixel* pIRMap)
03418         {
03419             return xnMockIRSetData(GetHandle(), nFrameID, nTimestamp, nDataSize, pIRMap);
03420         }
03421 
03429         inline XnStatus SetData(const IRMetaData& irMD, XnUInt32 nFrameID, XnUInt64 nTimestamp)
03430         {
03431             return SetData(nFrameID, nTimestamp, irMD.DataSize(), irMD.Data());
03432         }
03433 
03439         inline XnStatus SetData(const IRMetaData& irMD)
03440         {
03441             return SetData(irMD, irMD.FrameID(), irMD.Timestamp());
03442         }
03443     };
03444 
03449     class GestureGenerator : public Generator
03450     {
03451     public:
03457         inline GestureGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {} 
03458         inline GestureGenerator(const NodeWrapper& other) : Generator(other) {}
03459 
03463         inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL);
03464 
03468         inline XnStatus AddGesture(const XnChar* strGesture, XnBoundingBox3D* pArea)
03469         {
03470             return xnAddGesture(GetHandle(), strGesture, pArea);
03471         }
03472 
03476         inline XnStatus RemoveGesture(const XnChar* strGesture)
03477         {
03478             return xnRemoveGesture(GetHandle(), strGesture);
03479         }
03480 
03484         inline XnStatus GetActiveGestures(XnChar*& astrGestures, XnUInt16& nGestures) const
03485         {
03486             return xnGetActiveGestures(GetHandle(), &astrGestures, &nGestures);
03487         }
03488 
03492         inline XnStatus GetAllActiveGestures(XnChar** astrGestures, XnUInt32 nNameLength, XnUInt16& nGestures) const
03493         {
03494             return xnGetAllActiveGestures(GetHandle(), astrGestures, nNameLength, &nGestures);
03495         }
03496 
03500         inline XnStatus EnumerateGestures(XnChar*& astrGestures, XnUInt16& nGestures) const
03501         {
03502             return xnEnumerateGestures(GetHandle(), &astrGestures, &nGestures);
03503         }
03504 
03508         inline XnUInt16 GetNumberOfAvailableGestures() const
03509         {
03510             return xnGetNumberOfAvailableGestures(GetHandle());
03511         }
03512 
03516         inline XnStatus EnumerateAllGestures(XnChar** astrGestures, XnUInt32 nNameLength, XnUInt16& nGestures) const
03517         {
03518             return xnEnumerateAllGestures(GetHandle(), astrGestures, nNameLength, &nGestures);
03519         }
03520 
03524         inline XnBool IsGestureAvailable(const XnChar* strGesture) const
03525         {
03526             return xnIsGestureAvailable(GetHandle(), strGesture);
03527         }
03528 
03532         inline XnBool IsGestureProgressSupported(const XnChar* strGesture) const
03533         {
03534             return xnIsGestureProgressSupported(GetHandle(), strGesture);
03535         }
03536 
03546         typedef void (XN_CALLBACK_TYPE* GestureRecognized)(GestureGenerator& generator, const XnChar* strGesture, const XnPoint3D* pIDPosition, const XnPoint3D* pEndPosition, void* pCookie);
03556         typedef void (XN_CALLBACK_TYPE* GestureProgress)(GestureGenerator& generator, const XnChar* strGesture, const XnPoint3D* pPosition, XnFloat fProgress, void* pCookie);
03557 
03561         XnStatus RegisterGestureCallbacks(GestureRecognized RecognizedCB, GestureProgress ProgressCB, void* pCookie, XnCallbackHandle& hCallback)
03562         {
03563             XnStatus nRetVal = XN_STATUS_OK;
03564             
03565             GestureCookie* pGestureCookie;
03566             XN_VALIDATE_ALLOC(pGestureCookie, GestureCookie);
03567             pGestureCookie->recognizedHandler = RecognizedCB;
03568             pGestureCookie->progressHandler = ProgressCB;
03569             pGestureCookie->pUserCookie = pCookie;
03570 
03571             nRetVal = xnRegisterGestureCallbacks(GetHandle(), GestureRecognizedCallback, GestureProgressCallback, pGestureCookie, &pGestureCookie->hCallback);
03572             if (nRetVal != XN_STATUS_OK)
03573             {
03574                 xnOSFree(pGestureCookie);
03575                 return (nRetVal);
03576             }
03577 
03578             hCallback = pGestureCookie;
03579 
03580             return (XN_STATUS_OK);
03581         }
03582 
03586         inline void UnregisterGestureCallbacks(XnCallbackHandle hCallback)
03587         {
03588             GestureCookie* pGestureCookie = (GestureCookie*)hCallback;
03589             xnUnregisterGestureCallbacks(GetHandle(), pGestureCookie->hCallback);
03590             xnOSFree(pGestureCookie);
03591         }
03592 
03596         inline XnStatus RegisterToGestureChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
03597         {
03598             return _RegisterToStateChange(xnRegisterToGestureChange, GetHandle(), handler, pCookie, hCallback);
03599         }
03600 
03604         inline void UnregisterFromGestureChange(XnCallbackHandle hCallback)
03605         {
03606             _UnregisterFromStateChange(xnUnregisterFromGestureChange, GetHandle(), hCallback);
03607         }
03608 
03617         typedef void (XN_CALLBACK_TYPE* GestureIntermediateStageCompleted)(GestureGenerator& generator, const XnChar* strGesture, const XnPoint3D* pPosition, void* pCookie);
03621         XnStatus RegisterToGestureIntermediateStageCompleted(GestureIntermediateStageCompleted handler, void* pCookie, XnCallbackHandle& hCallback)
03622         {
03623             XnStatus nRetVal = XN_STATUS_OK;
03624 
03625             GestureIntermediateStageCompletedCookie* pGestureCookie;
03626             XN_VALIDATE_ALLOC(pGestureCookie, GestureIntermediateStageCompletedCookie);
03627             pGestureCookie->handler = handler;
03628             pGestureCookie->pUserCookie = pCookie;
03629 
03630             nRetVal = xnRegisterToGestureIntermediateStageCompleted(GetHandle(), GestureIntermediateStageCompletedCallback, pGestureCookie, &pGestureCookie->hCallback);
03631             if (nRetVal != XN_STATUS_OK)
03632             {
03633                 xnOSFree(pGestureCookie);
03634                 return (nRetVal);
03635             }
03636 
03637             hCallback = pGestureCookie;
03638 
03639             return (XN_STATUS_OK);
03640         }
03644         inline void UnregisterFromGestureIntermediateStageCompleted(XnCallbackHandle hCallback)
03645         {
03646             GestureIntermediateStageCompletedCookie* pGestureCookie = (GestureIntermediateStageCompletedCookie*)hCallback;
03647             xnUnregisterFromGestureIntermediateStageCompleted(GetHandle(), pGestureCookie->hCallback);
03648             xnOSFree(pGestureCookie);
03649         }
03650 
03659         typedef void (XN_CALLBACK_TYPE* GestureReadyForNextIntermediateStage)(GestureGenerator& generator, const XnChar* strGesture, const XnPoint3D* pPosition, void* pCookie);
03663         XnStatus RegisterToGestureReadyForNextIntermediateStage(GestureReadyForNextIntermediateStage handler, void* pCookie, XnCallbackHandle& hCallback)
03664         {
03665             XnStatus nRetVal = XN_STATUS_OK;
03666 
03667             GestureReadyForNextIntermediateStageCookie* pGestureCookie;
03668             XN_VALIDATE_ALLOC(pGestureCookie, GestureReadyForNextIntermediateStageCookie);
03669             pGestureCookie->handler = handler;
03670             pGestureCookie->pUserCookie = pCookie;
03671 
03672             nRetVal = xnRegisterToGestureReadyForNextIntermediateStage(GetHandle(), GestureReadyForNextIntermediateStageCallback, pGestureCookie, &pGestureCookie->hCallback);
03673             if (nRetVal != XN_STATUS_OK)
03674             {
03675                 xnOSFree(pGestureCookie);
03676                 return (nRetVal);
03677             }
03678 
03679             hCallback = pGestureCookie;
03680 
03681             return (XN_STATUS_OK);
03682         }
03683 
03687         inline void UnregisterFromGestureReadyForNextIntermediateStageCallbacks(XnCallbackHandle hCallback)
03688         {
03689             GestureReadyForNextIntermediateStageCookie* pGestureCookie = (GestureReadyForNextIntermediateStageCookie*)hCallback;
03690             xnUnregisterFromGestureReadyForNextIntermediateStage(GetHandle(), pGestureCookie->hCallback);
03691             xnOSFree(pGestureCookie);
03692         }
03693 
03694     private:
03695         typedef struct GestureCookie
03696         {
03697             GestureRecognized recognizedHandler;
03698             GestureProgress progressHandler;
03699             void* pUserCookie;
03700             XnCallbackHandle hCallback;
03701         } GestureCookie;
03702 
03703         static void XN_CALLBACK_TYPE GestureRecognizedCallback(XnNodeHandle hNode, const XnChar* strGesture, const XnPoint3D* pIDPosition, const XnPoint3D* pEndPosition, void* pCookie)
03704         {
03705             GestureCookie* pGestureCookie = (GestureCookie*)pCookie;
03706             GestureGenerator gen(hNode);
03707             if (pGestureCookie->recognizedHandler != NULL)
03708             {
03709                 pGestureCookie->recognizedHandler(gen, strGesture, pIDPosition, pEndPosition, pGestureCookie->pUserCookie);
03710             }
03711         }
03712 
03713         static void XN_CALLBACK_TYPE GestureProgressCallback(XnNodeHandle hNode, const XnChar* strGesture, const XnPoint3D* pPosition, XnFloat fProgress, void* pCookie)
03714         {
03715             GestureCookie* pGestureCookie = (GestureCookie*)pCookie;
03716             GestureGenerator gen(hNode);
03717             if (pGestureCookie->progressHandler != NULL)
03718             {
03719                 pGestureCookie->progressHandler(gen, strGesture, pPosition, fProgress, pGestureCookie->pUserCookie);
03720             }
03721         }
03722 
03723         typedef struct GestureIntermediateStageCompletedCookie
03724         {
03725             GestureIntermediateStageCompleted handler;
03726             void* pUserCookie;
03727             XnCallbackHandle hCallback;
03728         } GestureIntermediateStageCompletedCookie;
03729 
03730         static void XN_CALLBACK_TYPE GestureIntermediateStageCompletedCallback(XnNodeHandle hNode, const XnChar* strGesture, const XnPoint3D* pPosition, void* pCookie)
03731         {
03732             GestureIntermediateStageCompletedCookie* pGestureCookie = (GestureIntermediateStageCompletedCookie*)pCookie;
03733             GestureGenerator gen(hNode);
03734             if (pGestureCookie->handler != NULL)
03735             {
03736                 pGestureCookie->handler(gen, strGesture, pPosition, pGestureCookie->pUserCookie);
03737             }
03738         }
03739 
03740         typedef struct GestureReadyForNextIntermediateStageCookie
03741         {
03742             GestureReadyForNextIntermediateStage handler;
03743             void* pUserCookie;
03744             XnCallbackHandle hCallback;
03745         } GestureReadyForNextIntermediateStageCookie;
03746 
03747         static void XN_CALLBACK_TYPE GestureReadyForNextIntermediateStageCallback(XnNodeHandle hNode, const XnChar* strGesture, const XnPoint3D* pPosition, void* pCookie)
03748         {
03749             GestureReadyForNextIntermediateStageCookie* pGestureCookie = (GestureReadyForNextIntermediateStageCookie*)pCookie;
03750             GestureGenerator gen(hNode);
03751             if (pGestureCookie->handler != NULL)
03752             {
03753                 pGestureCookie->handler(gen, strGesture, pPosition, pGestureCookie->pUserCookie);
03754             }
03755         }
03756     };
03757 
03762     class SceneAnalyzer : public MapGenerator
03763     {
03764     public:
03770         inline SceneAnalyzer(XnNodeHandle hNode = NULL) : MapGenerator(hNode) {}
03771         inline SceneAnalyzer(const NodeWrapper& other) : MapGenerator(other) {}
03772 
03776         inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL);
03777 
03781         inline void GetMetaData(SceneMetaData& metaData) const
03782         {
03783             xnGetSceneMetaData(GetHandle(), metaData.GetUnderlying());
03784         }
03785 
03789         inline const XnLabel* GetLabelMap() const
03790         {
03791             return xnGetLabelMap(GetHandle());
03792         }
03793 
03797         inline XnStatus GetFloor(XnPlane3D& Plane) const
03798         {
03799             return xnGetFloor(GetHandle(), &Plane);
03800         }
03801     };
03802 
03807     class HandTouchingFOVEdgeCapability : public Capability
03808     {
03809     public:
03815         inline HandTouchingFOVEdgeCapability(XnNodeHandle hNode) : Capability(hNode) {}
03816         HandTouchingFOVEdgeCapability(const NodeWrapper& node) : Capability(node) {}
03817 
03828         typedef void (XN_CALLBACK_TYPE* HandTouchingFOVEdge)(HandTouchingFOVEdgeCapability& touchingfov, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, XnDirection eDir, void* pCookie);
03832         inline XnStatus RegisterToHandTouchingFOVEdge(HandTouchingFOVEdge handler, void* pCookie, XnCallbackHandle& hCallback)
03833         {
03834             XnStatus nRetVal = XN_STATUS_OK;
03835 
03836             HandTouchingFOVEdgeCookie* pHandCookie;
03837             XN_VALIDATE_ALLOC(pHandCookie, HandTouchingFOVEdgeCookie);
03838             pHandCookie->handler = handler;
03839             pHandCookie->pUserCookie = pCookie;
03840 
03841             nRetVal = xnRegisterToHandTouchingFOVEdge(GetHandle(), HandTouchingFOVEdgeCB, pHandCookie, &pHandCookie->hCallback);
03842             if (nRetVal != XN_STATUS_OK)
03843             {
03844                 xnOSFree(pHandCookie);
03845                 return (nRetVal);
03846             }
03847 
03848             hCallback = pHandCookie;
03849 
03850             return (XN_STATUS_OK);
03851         }
03852 
03856         inline void UnregisterFromHandTouchingFOVEdge(XnCallbackHandle hCallback)
03857         {
03858             HandTouchingFOVEdgeCookie* pHandCookie = (HandTouchingFOVEdgeCookie*)hCallback;
03859             xnUnregisterFromHandTouchingFOVEdge(GetHandle(), pHandCookie->hCallback);
03860             xnOSFree(pHandCookie);
03861         }
03862     private:
03863         typedef struct HandTouchingFOVEdgeCookie
03864         {
03865             HandTouchingFOVEdge handler;
03866             void* pUserCookie;
03867             XnCallbackHandle hCallback;
03868         } HandTouchingFOVEdgeCookie;
03869 
03870         static void XN_CALLBACK_TYPE HandTouchingFOVEdgeCB(XnNodeHandle hNode, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, XnDirection eDir, void* pCookie)
03871         {
03872             HandTouchingFOVEdgeCookie* pHandCookie = (HandTouchingFOVEdgeCookie*)pCookie;
03873             HandTouchingFOVEdgeCapability cap(hNode);
03874             if (pHandCookie->handler != NULL)
03875             {
03876                 pHandCookie->handler(cap, user, pPosition, fTime, eDir, pHandCookie->pUserCookie);
03877             }
03878         }
03879 
03880     };
03885     class HandsGenerator : public Generator
03886     {
03887     public:
03893         inline HandsGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {}
03894         inline HandsGenerator(const NodeWrapper& other) : Generator(other) {}
03895 
03899         inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL);
03900 
03910         typedef void (XN_CALLBACK_TYPE* HandCreate)(HandsGenerator& generator, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, void* pCookie);
03920         typedef void (XN_CALLBACK_TYPE* HandUpdate)(HandsGenerator& generator, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, void* pCookie);
03929         typedef void (XN_CALLBACK_TYPE* HandDestroy)(HandsGenerator& generator, XnUserID user, XnFloat fTime, void* pCookie);
03930 
03934         inline XnStatus RegisterHandCallbacks(HandCreate CreateCB, HandUpdate UpdateCB, HandDestroy DestroyCB, void* pCookie, XnCallbackHandle& hCallback)
03935         {
03936             XnStatus nRetVal = XN_STATUS_OK;
03937 
03938             HandCookie* pHandCookie;
03939             XN_VALIDATE_ALLOC(pHandCookie, HandCookie);
03940             pHandCookie->createHandler = CreateCB;
03941             pHandCookie->updateHandler = UpdateCB;
03942             pHandCookie->destroyHandler = DestroyCB;
03943             pHandCookie->pUserCookie = pCookie;
03944 
03945             nRetVal = xnRegisterHandCallbacks(GetHandle(), HandCreateCB, HandUpdateCB, HandDestroyCB, pHandCookie, &pHandCookie->hCallback);
03946             if (nRetVal != XN_STATUS_OK)
03947             {
03948                 xnOSFree(pHandCookie);
03949                 return (nRetVal);
03950             }
03951 
03952             hCallback = pHandCookie;
03953 
03954             return (XN_STATUS_OK);
03955         }
03956 
03960         inline void UnregisterHandCallbacks(XnCallbackHandle hCallback)
03961         {
03962             HandCookie* pHandCookie = (HandCookie*)hCallback;
03963             xnUnregisterHandCallbacks(GetHandle(), pHandCookie->hCallback);
03964             xnOSFree(pHandCookie);
03965         }
03966 
03970         inline XnStatus StopTracking(XnUserID user)
03971         {
03972             return xnStopTracking(GetHandle(), user);
03973         }
03974 
03978         inline XnStatus StopTrackingAll()
03979         {
03980             return xnStopTrackingAll(GetHandle());
03981         }
03982 
03986         inline XnStatus StartTracking(const XnPoint3D& ptPosition)
03987         {
03988             return xnStartTracking(GetHandle(), &ptPosition);
03989         }
03990 
03994         inline XnStatus SetSmoothing(XnFloat fSmoothingFactor)
03995         {
03996             return xnSetTrackingSmoothing(GetHandle(), fSmoothingFactor);
03997         }
03998 
04004         inline const HandTouchingFOVEdgeCapability GetHandTouchingFOVEdgeCap() const
04005         {
04006             return HandTouchingFOVEdgeCapability(GetHandle());
04007         }
04008 
04014         inline HandTouchingFOVEdgeCapability GetHandTouchingFOVEdgeCap()
04015         {
04016             return HandTouchingFOVEdgeCapability(GetHandle());
04017         }
04018 
04019     private:
04020         typedef struct HandCookie
04021         {
04022             HandCreate createHandler;
04023             HandUpdate updateHandler;
04024             HandDestroy destroyHandler;
04025             void* pUserCookie;
04026             XnCallbackHandle hCallback;
04027         } HandCookie;
04028 
04029         static void XN_CALLBACK_TYPE HandCreateCB(XnNodeHandle hNode, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, void* pCookie)
04030         {
04031             HandCookie* pHandCookie = (HandCookie*)pCookie;
04032             HandsGenerator gen(hNode);
04033             if (pHandCookie->createHandler != NULL)
04034             {
04035                 pHandCookie->createHandler(gen, user, pPosition, fTime, pHandCookie->pUserCookie);
04036             }
04037         }
04038         static void XN_CALLBACK_TYPE HandUpdateCB(XnNodeHandle hNode, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, void* pCookie)
04039         {
04040             HandCookie* pHandCookie = (HandCookie*)pCookie;
04041             HandsGenerator gen(hNode);
04042             if (pHandCookie->updateHandler != NULL)
04043             {
04044                 pHandCookie->updateHandler(gen, user, pPosition, fTime, pHandCookie->pUserCookie);
04045             }
04046         }
04047         static void XN_CALLBACK_TYPE HandDestroyCB(XnNodeHandle hNode, XnUserID user, XnFloat fTime, void* pCookie)
04048         {
04049             HandCookie* pHandCookie = (HandCookie*)pCookie;
04050             HandsGenerator gen(hNode);
04051             if (pHandCookie->destroyHandler != NULL)
04052             {
04053                 pHandCookie->destroyHandler(gen, user, fTime, pHandCookie->pUserCookie);
04054             }
04055         }
04056     };
04057 
04062     class SkeletonCapability : public Capability
04063     {
04064     public:
04070         inline SkeletonCapability(XnNodeHandle hNode) : Capability(hNode) {}
04071         SkeletonCapability(const NodeWrapper& node) : Capability(node) {}
04072 
04076         inline XnBool IsJointAvailable(XnSkeletonJoint eJoint) const
04077         {
04078             return xnIsJointAvailable(GetHandle(), eJoint);
04079         }
04080 
04084         inline XnBool IsProfileAvailable(XnSkeletonProfile eProfile) const
04085         {
04086             return xnIsProfileAvailable(GetHandle(), eProfile);
04087         }
04088 
04092         inline XnStatus SetSkeletonProfile(XnSkeletonProfile eProfile)
04093         {
04094             return xnSetSkeletonProfile(GetHandle(), eProfile);
04095         }
04096 
04100         inline XnStatus SetJointActive(XnSkeletonJoint eJoint, XnBool bState)
04101         {
04102             return xnSetJointActive(GetHandle(), eJoint, bState);
04103         }
04104 
04108         XN_API_DEPRECATED("Use the version with one argument") 
04109         inline XnBool IsJointActive(XnSkeletonJoint eJoint, XnBool /*bState*/) const
04110         {
04111             return xnIsJointActive(GetHandle(), eJoint);
04112         }
04113 
04117         inline XnBool IsJointActive(XnSkeletonJoint eJoint) const
04118         {
04119             return xnIsJointActive(GetHandle(), eJoint);
04120         }
04121 
04125         inline XnStatus RegisterToJointConfigurationChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
04126         {
04127             return _RegisterToStateChange(xnRegisterToJointConfigurationChange, GetHandle(), handler, pCookie, hCallback);
04128         }
04129 
04133         inline void UnregisterFromJointConfigurationChange(XnCallbackHandle hCallback)
04134         {
04135             _UnregisterFromStateChange(xnUnregisterFromJointConfigurationChange, GetHandle(), hCallback);
04136         }
04137 
04141         inline XnStatus EnumerateActiveJoints(XnSkeletonJoint* pJoints, XnUInt16& nJoints) const
04142         {
04143             return xnEnumerateActiveJoints(GetHandle(), pJoints, &nJoints);
04144         }
04145 
04149         inline XnStatus GetSkeletonJoint(XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointTransformation& Joint) const
04150         {
04151             return xnGetSkeletonJoint(GetHandle(), user, eJoint, &Joint);
04152         }
04153 
04157         inline XnStatus GetSkeletonJointPosition(XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointPosition& Joint) const
04158         {
04159             return xnGetSkeletonJointPosition(GetHandle(), user, eJoint, &Joint);
04160         }
04161 
04165         inline XnStatus GetSkeletonJointOrientation(XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointOrientation& Joint) const
04166         {
04167             return xnGetSkeletonJointOrientation(GetHandle(), user, eJoint, &Joint);
04168         }
04169 
04173         inline XnBool IsTracking(XnUserID user) const
04174         {
04175             return xnIsSkeletonTracking(GetHandle(), user);
04176         }
04177 
04181         inline XnBool IsCalibrated(XnUserID user) const
04182         {
04183             return xnIsSkeletonCalibrated(GetHandle(), user);
04184         }
04185 
04189         inline XnBool IsCalibrating(XnUserID user) const
04190         {
04191             return xnIsSkeletonCalibrating(GetHandle(), user);
04192         }
04193 
04197         inline XnStatus RequestCalibration(XnUserID user, XnBool bForce)
04198         {
04199             return xnRequestSkeletonCalibration(GetHandle(), user, bForce);
04200         }
04201 
04205         inline XnStatus AbortCalibration(XnUserID user)
04206         {
04207             return xnAbortSkeletonCalibration(GetHandle(), user);
04208         }
04209 
04213         inline XnStatus SaveCalibrationDataToFile(XnUserID user, const XnChar* strFileName)
04214         {
04215             return xnSaveSkeletonCalibrationDataToFile(GetHandle(), user, strFileName);
04216         }
04217 
04221         inline XnStatus LoadCalibrationDataFromFile(XnUserID user, const XnChar* strFileName)
04222         {
04223             return xnLoadSkeletonCalibrationDataFromFile(GetHandle(), user, strFileName);
04224         }
04225 
04229         inline XnStatus SaveCalibrationData(XnUserID user, XnUInt32 nSlot)
04230         {
04231             return xnSaveSkeletonCalibrationData(GetHandle(), user, nSlot);
04232         }
04233 
04237         inline XnStatus LoadCalibrationData(XnUserID user, XnUInt32 nSlot)
04238         {
04239             return xnLoadSkeletonCalibrationData(GetHandle(), user, nSlot);
04240         }
04241 
04245         inline XnStatus ClearCalibrationData(XnUInt32 nSlot)
04246         {
04247             return xnClearSkeletonCalibrationData(GetHandle(), nSlot);
04248         }
04249 
04253         inline XnBool IsCalibrationData(XnUInt32 nSlot) const
04254         {
04255             return xnIsSkeletonCalibrationData(GetHandle(), nSlot);
04256         }
04257 
04261         inline XnStatus StartTracking(XnUserID user)
04262         {
04263             return xnStartSkeletonTracking(GetHandle(), user);
04264         }
04265 
04269         inline XnStatus StopTracking(XnUserID user)
04270         {
04271             return xnStopSkeletonTracking(GetHandle(), user);
04272         }
04273 
04277         inline XnStatus Reset(XnUserID user)
04278         {
04279             return xnResetSkeleton(GetHandle(), user);
04280         }
04281 
04285         inline XnBool NeedPoseForCalibration() const
04286         {
04287             return xnNeedPoseForSkeletonCalibration(GetHandle());
04288         }
04289 
04293         inline XnStatus GetCalibrationPose(XnChar* strPose) const
04294         {
04295             return xnGetSkeletonCalibrationPose(GetHandle(), strPose);
04296         }
04297 
04301         inline XnStatus SetSmoothing(XnFloat fSmoothingFactor)
04302         {
04303             return xnSetSkeletonSmoothing(GetHandle(), fSmoothingFactor);
04304         }
04305 
04313         typedef void (XN_CALLBACK_TYPE* CalibrationStart)(SkeletonCapability& skeleton, XnUserID user, void* pCookie);
04322         typedef void (XN_CALLBACK_TYPE* CalibrationEnd)(SkeletonCapability& skeleton, XnUserID user, XnBool bSuccess, void* pCookie);
04323 
04327         inline XnStatus XN_API_DEPRECATED("Please use RegisterToCalibrationStart/Complete") RegisterCalibrationCallbacks(CalibrationStart CalibrationStartCB, CalibrationEnd CalibrationEndCB, void* pCookie, XnCallbackHandle& hCallback)
04328         {
04329             XnStatus nRetVal = XN_STATUS_OK;
04330 
04331             SkeletonCookie* pSkeletonCookie;
04332             XN_VALIDATE_ALLOC(pSkeletonCookie, SkeletonCookie);
04333             pSkeletonCookie->startHandler = CalibrationStartCB;
04334             pSkeletonCookie->endHandler = CalibrationEndCB;
04335             pSkeletonCookie->pUserCookie = pCookie;
04336 
04337 #pragma warning (push)
04338 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
04339             nRetVal = xnRegisterCalibrationCallbacks(GetHandle(), CalibrationStartBundleCallback, CalibrationEndBundleCallback, pSkeletonCookie, &pSkeletonCookie->hCallback);
04340 #pragma warning (pop)
04341             if (nRetVal != XN_STATUS_OK)
04342             {
04343                 xnOSFree(pSkeletonCookie);
04344                 return (nRetVal);
04345             }
04346 
04347             hCallback = pSkeletonCookie;
04348 
04349             return (XN_STATUS_OK);
04350         }
04351 
04355         inline void XN_API_DEPRECATED("Please use UnregisterFromCalibrationStart/Complete") UnregisterCalibrationCallbacks(XnCallbackHandle hCallback)
04356         {
04357             SkeletonCookie* pSkeletonCookie = (SkeletonCookie*)hCallback;
04358 #pragma warning (push)
04359 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
04360             xnUnregisterCalibrationCallbacks(GetHandle(), pSkeletonCookie->hCallback);
04361 #pragma warning (pop)
04362             xnOSFree(pSkeletonCookie);
04363         }
04364 
04368         inline XnStatus RegisterToCalibrationStart(CalibrationStart handler, void* pCookie, XnCallbackHandle& hCallback)
04369         {
04370             XnStatus nRetVal = XN_STATUS_OK;
04371             CalibrationStartCookie* pCalibrationCookie;
04372             XN_VALIDATE_ALLOC(pCalibrationCookie, CalibrationStartCookie);
04373             pCalibrationCookie->handler = handler;
04374             pCalibrationCookie->pUserCookie = pCookie;
04375             nRetVal = xnRegisterToCalibrationStart(GetHandle(), CalibrationStartCallback, pCalibrationCookie, &pCalibrationCookie->hCallback);
04376             if (nRetVal != XN_STATUS_OK)
04377             {
04378                 xnOSFree(pCalibrationCookie);
04379                 return nRetVal;
04380             }
04381             hCallback = pCalibrationCookie;
04382             return XN_STATUS_OK;
04383         }
04384 
04391         inline XnStatus UnregisterFromCalibrationStart(XnCallbackHandle hCallback)
04392         {
04393             CalibrationStartCookie* pCalibrationCookie = (CalibrationStartCookie*)hCallback;
04394             xnUnregisterFromCalibrationStart(GetHandle(), pCalibrationCookie->hCallback);
04395             xnOSFree(pCalibrationCookie);
04396             return XN_STATUS_OK;
04397         }
04398 
04407         typedef void (XN_CALLBACK_TYPE* CalibrationInProgress)(SkeletonCapability& skeleton, XnUserID user, XnCalibrationStatus calibrationError, void* pCookie);
04408 
04412         inline XnStatus RegisterToCalibrationInProgress(CalibrationInProgress handler, void* pCookie, XnCallbackHandle& hCallback)
04413         {
04414             XnStatus nRetVal = XN_STATUS_OK;
04415 
04416             CalibrationInProgressCookie* pSkeletonCookie;
04417             XN_VALIDATE_ALLOC(pSkeletonCookie, CalibrationInProgressCookie);
04418             pSkeletonCookie->handler = handler;
04419             pSkeletonCookie->pUserCookie = pCookie;
04420 
04421             nRetVal = xnRegisterToCalibrationInProgress(GetHandle(), CalibrationInProgressCallback, pSkeletonCookie, &pSkeletonCookie->hCallback);
04422             if (nRetVal != XN_STATUS_OK)
04423             {
04424                 xnOSFree(pSkeletonCookie);
04425                 return (nRetVal);
04426             }
04427 
04428             hCallback = pSkeletonCookie;
04429 
04430             return (XN_STATUS_OK);
04431         }
04432 
04436         inline void UnregisterFromCalibrationInProgress(XnCallbackHandle hCallback)
04437         {
04438             CalibrationInProgressCookie* pSkeletonCookie = (CalibrationInProgressCookie*)hCallback;
04439             xnUnregisterFromCalibrationInProgress(GetHandle(), pSkeletonCookie->hCallback);
04440             xnOSFree(pSkeletonCookie);
04441         }
04442 
04451         typedef void (XN_CALLBACK_TYPE* CalibrationComplete)(SkeletonCapability& skeleton, XnUserID user, XnCalibrationStatus calibrationError, void* pCookie);
04455         inline XnStatus RegisterToCalibrationComplete(CalibrationComplete handler, void* pCookie, XnCallbackHandle& hCallback)
04456         {
04457             XnStatus nRetVal = XN_STATUS_OK;
04458 
04459             CalibrationCompleteCookie* pSkeletonCookie;
04460             XN_VALIDATE_ALLOC(pSkeletonCookie, CalibrationCompleteCookie);
04461             pSkeletonCookie->handler = handler;
04462             pSkeletonCookie->pUserCookie = pCookie;
04463 
04464             nRetVal = xnRegisterToCalibrationComplete(GetHandle(), CalibrationCompleteCallback, pSkeletonCookie, &pSkeletonCookie->hCallback);
04465             if (nRetVal != XN_STATUS_OK)
04466             {
04467                 xnOSFree(pSkeletonCookie);
04468                 return (nRetVal);
04469             }
04470 
04471             hCallback = pSkeletonCookie;
04472 
04473             return (XN_STATUS_OK);
04474         }
04475 
04479         inline void UnregisterFromCalibrationComplete(XnCallbackHandle hCallback)
04480         {
04481             CalibrationCompleteCookie* pSkeletonCookie = (CalibrationCompleteCookie*)hCallback;
04482             xnUnregisterFromCalibrationComplete(GetHandle(), pSkeletonCookie->hCallback);
04483             xnOSFree(pSkeletonCookie);
04484         }
04485     private:
04486         typedef struct SkeletonCookie
04487         {
04488             CalibrationStart startHandler;
04489             CalibrationEnd endHandler;
04490             void* pUserCookie;
04491             XnCallbackHandle hCallback;
04492         } SkeletonCookie;
04493 
04494         static void XN_CALLBACK_TYPE CalibrationStartBundleCallback(XnNodeHandle hNode, XnUserID user, void* pCookie)
04495         {
04496             SkeletonCookie* pSkeletonCookie = (SkeletonCookie*)pCookie;
04497             SkeletonCapability cap(hNode);
04498             if (pSkeletonCookie->startHandler != NULL)
04499             {
04500                 pSkeletonCookie->startHandler(cap, user, pSkeletonCookie->pUserCookie);
04501             }
04502         }
04503 
04504         static void XN_CALLBACK_TYPE CalibrationEndBundleCallback(XnNodeHandle hNode, XnUserID user, XnBool bSuccess, void* pCookie)
04505         {
04506             SkeletonCookie* pSkeletonCookie = (SkeletonCookie*)pCookie;
04507             SkeletonCapability cap(hNode);
04508             if (pSkeletonCookie->endHandler != NULL)
04509             {
04510                 pSkeletonCookie->endHandler(cap, user, bSuccess, pSkeletonCookie->pUserCookie);
04511             }
04512         }
04513         typedef struct CalibrationStartCookie
04514         {
04515             CalibrationStart handler;
04516             void* pUserCookie;
04517             XnCallbackHandle hCallback;
04518         } CalibrationStartCookie;
04519 
04520         static void XN_CALLBACK_TYPE CalibrationStartCallback(XnNodeHandle hNode, XnUserID user, void* pCookie)
04521         {
04522             CalibrationStartCookie* pCalibrationCookie = (CalibrationStartCookie*)pCookie;
04523             SkeletonCapability cap(hNode);
04524             if (pCalibrationCookie->handler != NULL)
04525             {
04526                 pCalibrationCookie->handler(cap, user, pCalibrationCookie->pUserCookie);
04527             }
04528         }
04529         typedef struct CalibrationInProgressCookie
04530         {
04531             CalibrationInProgress handler;
04532             void* pUserCookie;
04533             XnCallbackHandle hCallback;
04534         } CalibrationInProgressCookie;
04535 
04536         static void XN_CALLBACK_TYPE CalibrationInProgressCallback(XnNodeHandle hNode, XnUserID user, XnCalibrationStatus calibrationError, void* pCookie)
04537         {
04538             CalibrationInProgressCookie* pSkeletonCookie = (CalibrationInProgressCookie*)pCookie;
04539             SkeletonCapability cap(hNode);
04540             if (pSkeletonCookie->handler != NULL)
04541             {
04542                 pSkeletonCookie->handler(cap, user, calibrationError, pSkeletonCookie->pUserCookie);
04543             }
04544         }
04545 
04546         typedef struct CalibrationCompleteCookie
04547         {
04548             CalibrationComplete handler;
04549             void* pUserCookie;
04550             XnCallbackHandle hCallback;
04551         } CalibrationCompleteCookie;
04552 
04553         static void XN_CALLBACK_TYPE CalibrationCompleteCallback(XnNodeHandle hNode, XnUserID user, XnCalibrationStatus calibrationError, void* pCookie)
04554         {
04555             CalibrationCompleteCookie* pSkeletonCookie = (CalibrationCompleteCookie*)pCookie;
04556             SkeletonCapability cap(hNode);
04557             if (pSkeletonCookie->handler != NULL)
04558             {
04559                 pSkeletonCookie->handler(cap, user, calibrationError, pSkeletonCookie->pUserCookie);
04560             }
04561         }
04562     };
04563 
04568     class PoseDetectionCapability : public Capability
04569     {
04570     public:
04576         inline PoseDetectionCapability(XnNodeHandle hNode) : Capability(hNode) {}
04577         PoseDetectionCapability(const NodeWrapper& node) : Capability(node) {}
04578 
04587         typedef void (XN_CALLBACK_TYPE* PoseDetection)(PoseDetectionCapability& pose, const XnChar* strPose, XnUserID user, void* pCookie);
04588 
04592         inline XnUInt32 GetNumberOfPoses() const
04593         {
04594             return xnGetNumberOfPoses(GetHandle());
04595         }
04596 
04600         inline XnStatus GetAvailablePoses(XnChar** pstrPoses, XnUInt32& nPoses) const
04601         {
04602             return xnGetAvailablePoses(GetHandle(), pstrPoses, &nPoses);
04603         }
04607         inline XnStatus GetAllAvailablePoses(XnChar** pstrPoses, XnUInt32 nNameLength, XnUInt32& nPoses) const
04608         {
04609             return xnGetAllAvailablePoses(GetHandle(), pstrPoses, nNameLength, &nPoses);
04610         }
04611 
04612         inline XnBool IsPoseSupported(const XnChar* strPose)
04613         {
04614             return xnIsPoseSupported(GetHandle(), strPose);
04615         }
04616 
04617         inline XnStatus GetPoseStatus(XnUserID userID, const XnChar* poseName, XnUInt64& poseTime, XnPoseDetectionStatus& eStatus, XnPoseDetectionState& eState)
04618         {
04619             return xnGetPoseStatus(GetHandle(), userID, poseName, &poseTime, &eStatus, &eState);
04620         }
04621 
04625         inline XnStatus StartPoseDetection(const XnChar* strPose, XnUserID user)
04626         {
04627             return xnStartPoseDetection(GetHandle(), strPose, user);
04628         }
04629 
04633         inline XnStatus StopPoseDetection(XnUserID user)
04634         {
04635             return xnStopPoseDetection(GetHandle(), user);
04636         }
04637 
04641         inline XnStatus StopSinglePoseDetection(XnUserID user, const XnChar* strPose)
04642         {
04643             return xnStopSinglePoseDetection(GetHandle(), user, strPose);
04644         }
04645 
04649         inline XnStatus XN_API_DEPRECATED("Please use RegisterToPoseDetected/RegisterToOutOfPose instead") RegisterToPoseCallbacks(PoseDetection PoseStartCB, PoseDetection PoseEndCB, void* pCookie, XnCallbackHandle& hCallback)
04650         {
04651             XnStatus nRetVal = XN_STATUS_OK;
04652 
04653             PoseCookie* pPoseCookie;
04654             XN_VALIDATE_ALLOC(pPoseCookie, PoseCookie);
04655             pPoseCookie->startHandler = PoseStartCB;
04656             pPoseCookie->endHandler = PoseEndCB;
04657             pPoseCookie->pPoseCookie = pCookie;
04658 
04659 #pragma warning (push)
04660 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
04661             nRetVal = xnRegisterToPoseCallbacks(GetHandle(), PoseDetectionStartBundleCallback, PoseDetectionStartEndBundleCallback, pPoseCookie, &pPoseCookie->hCallback);
04662 #pragma warning (pop)
04663             if (nRetVal != XN_STATUS_OK)
04664             {
04665                 xnOSFree(pPoseCookie);
04666                 return (nRetVal);
04667             }
04668 
04669             hCallback = pPoseCookie;
04670 
04671             return (XN_STATUS_OK);
04672         }
04673 
04677         inline void XN_API_DEPRECATED("Please use UnregisterFromPoseDetected/UnregisterFromOutOfPose instead") UnregisterFromPoseCallbacks(XnCallbackHandle hCallback)
04678         {
04679             PoseCookie* pPoseCookie = (PoseCookie*)hCallback;
04680 #pragma warning (push)
04681 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
04682             xnUnregisterFromPoseCallbacks(GetHandle(), pPoseCookie->hCallback);
04683 #pragma warning (pop)
04684             xnOSFree(pPoseCookie);
04685         }
04686 
04690         inline XnStatus RegisterToPoseDetected(PoseDetection handler, void* pCookie, XnCallbackHandle& hCallback)
04691         {
04692             XnStatus nRetVal = XN_STATUS_OK;
04693             PoseDetectionCookie* pPoseCookie;
04694             XN_VALIDATE_ALLOC(pPoseCookie, PoseDetectionCookie);
04695             pPoseCookie->handler = handler;
04696             pPoseCookie->pPoseCookie = pCookie;
04697 
04698             nRetVal = xnRegisterToPoseDetected(GetHandle(), PoseDetectionCallback, pPoseCookie, &pPoseCookie->hCallback);
04699             if (nRetVal != XN_STATUS_OK)
04700             {
04701                 xnOSFree(pPoseCookie);
04702                 return nRetVal;
04703             }
04704             hCallback = pPoseCookie;
04705             return XN_STATUS_OK;
04706         }
04710         inline XnStatus RegisterToOutOfPose(PoseDetection handler, void* pCookie, XnCallbackHandle& hCallback)
04711         {
04712             XnStatus nRetVal = XN_STATUS_OK;
04713             PoseDetectionCookie* pPoseCookie;
04714             XN_VALIDATE_ALLOC(pPoseCookie, PoseDetectionCookie);
04715             pPoseCookie->handler = handler;
04716             pPoseCookie->pPoseCookie = pCookie;
04717 
04718             nRetVal = xnRegisterToOutOfPose(GetHandle(), PoseDetectionCallback, pPoseCookie, &pPoseCookie->hCallback);
04719             if (nRetVal != XN_STATUS_OK)
04720             {
04721                 xnOSFree(pPoseCookie);
04722                 return nRetVal;
04723             }
04724             hCallback = pPoseCookie;
04725             return XN_STATUS_OK;
04726         }
04730         inline void UnregisterFromPoseDetected(XnCallbackHandle hCallback)
04731         {
04732             PoseDetectionCookie* pPoseCookie = (PoseDetectionCookie*)hCallback;
04733             xnUnregisterFromPoseDetected(GetHandle(), pPoseCookie->hCallback);
04734             xnOSFree(pPoseCookie);
04735         }
04739         inline void UnregisterFromOutOfPose(XnCallbackHandle hCallback)
04740         {
04741             PoseDetectionCookie* pPoseCookie = (PoseDetectionCookie*)hCallback;
04742             xnUnregisterFromOutOfPose(GetHandle(), pPoseCookie->hCallback);
04743             xnOSFree(pPoseCookie);
04744         }
04745 
04755         typedef void (XN_CALLBACK_TYPE* PoseInProgress)(PoseDetectionCapability& pose, const XnChar* strPose, XnUserID user, XnPoseDetectionStatus poseError, void* pCookie);
04759         inline XnStatus RegisterToPoseInProgress(PoseInProgress handler, void* pCookie, XnCallbackHandle& hCallback)
04760         {
04761             XnStatus nRetVal = XN_STATUS_OK;
04762 
04763             PoseInProgressCookie* pPoseCookie;
04764             XN_VALIDATE_ALLOC(pPoseCookie, PoseInProgressCookie);
04765             pPoseCookie->handler = handler;
04766             pPoseCookie->pPoseCookie = pCookie;
04767 
04768             nRetVal = xnRegisterToPoseDetectionInProgress(GetHandle(), PoseDetectionInProgressCallback, pPoseCookie, &pPoseCookie->hCallback);
04769             if (nRetVal != XN_STATUS_OK)
04770             {
04771                 xnOSFree(pPoseCookie);
04772                 return (nRetVal);
04773             }
04774 
04775             hCallback = pPoseCookie;
04776 
04777             return (XN_STATUS_OK);
04778         }
04779 
04783         inline void UnregisterFromPoseInProgress(XnCallbackHandle hCallback)
04784         {
04785             PoseInProgressCookie* pPoseCookie = (PoseInProgressCookie*)hCallback;
04786             xnUnregisterFromPoseDetectionInProgress(GetHandle(), pPoseCookie->hCallback);
04787             xnOSFree(pPoseCookie);
04788         }
04789 
04790     private:
04791         typedef struct PoseCookie
04792         {
04793             PoseDetection startHandler;
04794             PoseDetection endHandler;
04795             void* pPoseCookie;
04796             XnCallbackHandle hCallback;
04797         } PoseCookie;
04798 
04799         static void XN_CALLBACK_TYPE PoseDetectionStartBundleCallback(XnNodeHandle hNode, const XnChar* strPose, XnUserID user, void* pCookie)
04800         {
04801             PoseCookie* pPoseCookie = (PoseCookie*)pCookie;
04802             PoseDetectionCapability cap(hNode);
04803             if (pPoseCookie->startHandler != NULL)
04804             {
04805                 pPoseCookie->startHandler(cap, strPose, user, pPoseCookie->pPoseCookie);
04806             }
04807         }
04808 
04809         static void XN_CALLBACK_TYPE PoseDetectionStartEndBundleCallback(XnNodeHandle hNode, const XnChar* strPose, XnUserID user, void* pCookie)
04810         {
04811             PoseCookie* pPoseCookie = (PoseCookie*)pCookie;
04812             PoseDetectionCapability cap(hNode);
04813             if (pPoseCookie->endHandler != NULL)
04814             {
04815                 pPoseCookie->endHandler(cap, strPose, user, pPoseCookie->pPoseCookie);
04816             }
04817         }
04818         typedef struct PoseDetectionCookie
04819         {
04820             PoseDetection handler;
04821             void* pPoseCookie;
04822             XnCallbackHandle hCallback;
04823         } PoseDetectionCookie;
04824         static void XN_CALLBACK_TYPE PoseDetectionCallback(XnNodeHandle hNode, const XnChar* strPose, XnUserID user, void* pCookie)
04825         {
04826             PoseDetectionCookie* pPoseDetectionCookie = (PoseDetectionCookie*)pCookie;
04827             PoseDetectionCapability cap(hNode);
04828             if (pPoseDetectionCookie->handler != NULL)
04829             {
04830                 pPoseDetectionCookie->handler(cap, strPose, user, pPoseDetectionCookie->pPoseCookie);
04831             }
04832         }
04833 
04834         typedef struct PoseInProgressCookie
04835         {
04836             PoseInProgress handler;
04837             void* pPoseCookie;
04838             XnCallbackHandle hCallback;
04839         } PoseInProgressCookie;
04840 
04841         static void XN_CALLBACK_TYPE PoseDetectionInProgressCallback(XnNodeHandle hNode, const XnChar* strPose, XnUserID user, XnPoseDetectionStatus poseErrors, void* pCookie)
04842         {
04843             PoseInProgressCookie* pPoseCookie = (PoseInProgressCookie*)pCookie;
04844             PoseDetectionCapability cap(hNode);
04845             if (pPoseCookie->handler != NULL)
04846             {
04847                 pPoseCookie->handler(cap, strPose, user, poseErrors, pPoseCookie->pPoseCookie);
04848             }
04849         }
04850     };
04851 
04856     class UserGenerator : public Generator
04857     {
04858     public:
04864         inline UserGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {}
04865         inline UserGenerator(const NodeWrapper& other) : Generator(other) {}
04866 
04870         inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL);
04871 
04872         typedef void (XN_CALLBACK_TYPE* UserHandler)(UserGenerator& generator, XnUserID user, void* pCookie);
04873 
04877         inline XnUInt16 GetNumberOfUsers() const
04878         {
04879             return xnGetNumberOfUsers(GetHandle());
04880         }
04881 
04885         inline XnStatus GetUsers(XnUserID aUsers[], XnUInt16& nUsers) const
04886         {
04887             return xnGetUsers(GetHandle(), aUsers, &nUsers);
04888         }
04889 
04893         inline XnStatus GetCoM(XnUserID user, XnPoint3D& com) const
04894         {
04895             return xnGetUserCoM(GetHandle(), user, &com);
04896         }
04897 
04901         inline XnStatus GetUserPixels(XnUserID user, SceneMetaData& smd) const
04902         {
04903             return xnGetUserPixels(GetHandle(), user, smd.GetUnderlying());
04904         }
04905         
04909         inline XnStatus RegisterUserCallbacks(UserHandler NewUserCB, UserHandler LostUserCB, void* pCookie, XnCallbackHandle& hCallback)
04910         {
04911             XnStatus nRetVal = XN_STATUS_OK;
04912 
04913             UserCookie* pUserCookie;
04914             XN_VALIDATE_ALLOC(pUserCookie, UserCookie);
04915             pUserCookie->newHandler = NewUserCB;
04916             pUserCookie->lostHandler = LostUserCB;
04917             pUserCookie->pUserCookie = pCookie;
04918 
04919             nRetVal = xnRegisterUserCallbacks(GetHandle(), NewUserCallback, LostUserCallback, pUserCookie, &pUserCookie->hCallback);
04920             if (nRetVal != XN_STATUS_OK)
04921             {
04922                 xnOSFree(pUserCookie);
04923                 return (nRetVal);
04924             }
04925 
04926             hCallback = pUserCookie;
04927 
04928             return (XN_STATUS_OK);
04929         }
04930 
04934         inline void UnregisterUserCallbacks(XnCallbackHandle hCallback)
04935         {
04936             UserCookie* pUserCookie = (UserCookie*)hCallback;
04937             xnUnregisterUserCallbacks(GetHandle(), pUserCookie->hCallback);
04938             xnOSFree(pUserCookie);
04939         }
04940 
04946         inline const SkeletonCapability GetSkeletonCap() const
04947         {
04948             return SkeletonCapability(GetHandle());
04949         }
04950 
04956         inline SkeletonCapability GetSkeletonCap()
04957         {
04958             return SkeletonCapability(GetHandle());
04959         }
04960 
04966         inline const PoseDetectionCapability GetPoseDetectionCap() const
04967         {
04968             return PoseDetectionCapability(GetHandle());
04969         }
04970 
04976         inline PoseDetectionCapability GetPoseDetectionCap()
04977         {
04978             return PoseDetectionCapability(GetHandle());
04979         }
04980 
04984         inline XnStatus RegisterToUserExit(UserHandler handler, void* pCookie, XnCallbackHandle& hCallback)
04985         {
04986             XnStatus nRetVal = XN_STATUS_OK;
04987 
04988             UserSingleCookie* pUserCookie;
04989             XN_VALIDATE_ALLOC(pUserCookie, UserSingleCookie);
04990             pUserCookie->handler = handler;
04991             pUserCookie->pUserCookie = pCookie;
04992 
04993             nRetVal = xnRegisterToUserExit(GetHandle(), UserSingleCallback, pUserCookie, &pUserCookie->hCallback);
04994             if (nRetVal != XN_STATUS_OK)
04995             {
04996                 xnOSFree(pUserCookie);
04997                 return (nRetVal);
04998             }
04999 
05000             hCallback = pUserCookie;
05001 
05002             return (XN_STATUS_OK);
05003         }
05004 
05008         inline void UnregisterFromUserExit(XnCallbackHandle hCallback)
05009         {
05010             UserSingleCookie* pUserCookie = (UserSingleCookie*)hCallback;
05011             xnUnregisterFromUserExit(GetHandle(), pUserCookie->hCallback);
05012             xnOSFree(pUserCookie);
05013         }
05014 
05018         inline XnStatus RegisterToUserReEnter(UserHandler handler, void* pCookie, XnCallbackHandle& hCallback)
05019         {
05020             XnStatus nRetVal = XN_STATUS_OK;
05021 
05022             UserSingleCookie* pUserCookie;
05023             XN_VALIDATE_ALLOC(pUserCookie, UserSingleCookie);
05024             pUserCookie->handler = handler;
05025             pUserCookie->pUserCookie = pCookie;
05026 
05027             nRetVal = xnRegisterToUserReEnter(GetHandle(), UserSingleCallback, pUserCookie, &pUserCookie->hCallback);
05028             if (nRetVal != XN_STATUS_OK)
05029             {
05030                 xnOSFree(pUserCookie);
05031                 return (nRetVal);
05032             }
05033 
05034             hCallback = pUserCookie;
05035 
05036             return (XN_STATUS_OK);
05037         }
05038 
05042         inline void UnregisterFromUserReEnter(XnCallbackHandle hCallback)
05043         {
05044             UserSingleCookie* pUserCookie = (UserSingleCookie*)hCallback;
05045             xnUnregisterFromUserReEnter(GetHandle(), pUserCookie->hCallback);
05046             xnOSFree(pUserCookie);
05047         }
05048 
05049     private:
05050         typedef struct UserCookie
05051         {
05052             UserHandler newHandler;
05053             UserHandler lostHandler;
05054             void* pUserCookie;
05055             XnCallbackHandle hCallback;
05056         } UserCookie;
05057 
05058         static void XN_CALLBACK_TYPE NewUserCallback(XnNodeHandle hNode, XnUserID user, void* pCookie)
05059         {
05060             UserCookie* pUserCookie = (UserCookie*)pCookie;
05061             UserGenerator gen(hNode);
05062             if (pUserCookie->newHandler != NULL)
05063             {
05064                 pUserCookie->newHandler(gen, user, pUserCookie->pUserCookie);
05065             }
05066         }
05067 
05068         static void XN_CALLBACK_TYPE LostUserCallback(XnNodeHandle hNode, XnUserID user, void* pCookie)
05069         {
05070             UserCookie* pUserCookie = (UserCookie*)pCookie;
05071             UserGenerator gen(hNode);
05072             if (pUserCookie->lostHandler != NULL)
05073             {
05074                 pUserCookie->lostHandler(gen, user, pUserCookie->pUserCookie);
05075             }
05076         }
05077 
05078         typedef struct UserSingleCookie
05079         {
05080             UserHandler handler;
05081             void* pUserCookie;
05082             XnCallbackHandle hCallback;
05083         } UserSingleCookie;
05084 
05085         static void XN_CALLBACK_TYPE UserSingleCallback(XnNodeHandle hNode, XnUserID user, void* pCookie)
05086         {
05087             UserSingleCookie* pUserCookie = (UserSingleCookie*)pCookie;
05088             UserGenerator gen(hNode);
05089             if (pUserCookie->handler != NULL)
05090             {
05091                 pUserCookie->handler(gen, user, pUserCookie->pUserCookie);
05092             }
05093         }
05094     };
05095 
05100     class AudioGenerator : public Generator
05101     {
05102     public:
05108         inline AudioGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {}
05109         inline AudioGenerator(const NodeWrapper& other) : Generator(other) {}
05110 
05114         inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL);
05115 
05119         inline void GetMetaData(AudioMetaData& metaData) const
05120         {
05121             xnGetAudioMetaData(GetHandle(), metaData.GetUnderlying());
05122         }
05123 
05127         inline const XnUChar* GetAudioBuffer() const
05128         {
05129             return xnGetAudioBuffer(GetHandle());
05130         }
05131 
05135         inline XnUInt32 GetSupportedWaveOutputModesCount() const
05136         {
05137             return xnGetSupportedWaveOutputModesCount(GetHandle());
05138         }
05139 
05143         inline XnStatus GetSupportedWaveOutputModes(XnWaveOutputMode* aSupportedModes, XnUInt32& nCount) const
05144         {
05145             return xnGetSupportedWaveOutputModes(GetHandle(), aSupportedModes, &nCount);
05146         }
05147 
05151         inline XnStatus SetWaveOutputMode(const XnWaveOutputMode& OutputMode)
05152         {
05153             return xnSetWaveOutputMode(GetHandle(), &OutputMode);
05154         }
05155 
05159         inline XnStatus GetWaveOutputMode(XnWaveOutputMode& OutputMode) const
05160         {
05161             return xnGetWaveOutputMode(GetHandle(), &OutputMode);
05162         }
05163 
05167         inline XnStatus RegisterToWaveOutputModeChanges(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
05168         {
05169             return _RegisterToStateChange(xnRegisterToWaveOutputModeChanges, GetHandle(), handler, pCookie, hCallback);
05170         }
05171 
05175         inline void UnregisterFromWaveOutputModeChanges(XnCallbackHandle hCallback)
05176         {
05177             _UnregisterFromStateChange(xnUnregisterFromWaveOutputModeChanges, GetHandle(), hCallback);
05178         }
05179     };
05180 
05185     class MockAudioGenerator : public AudioGenerator
05186     {
05187     public:
05193         inline MockAudioGenerator(XnNodeHandle hNode = NULL) : AudioGenerator(hNode) {}
05194         inline MockAudioGenerator(const NodeWrapper& other) : AudioGenerator(other) {}
05195 
05202         XnStatus Create(Context& context, const XnChar* strName = NULL);
05203 
05210         XnStatus CreateBasedOn(AudioGenerator& other, const XnChar* strName = NULL);
05211 
05215         inline XnStatus SetData(XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize, const XnUInt8* pAudioBuffer)
05216         {
05217             return xnMockAudioSetData(GetHandle(), nFrameID, nTimestamp, nDataSize, pAudioBuffer);
05218         }
05219 
05227         inline XnStatus SetData(const AudioMetaData& audioMD, XnUInt32 nFrameID, XnUInt64 nTimestamp)
05228         {
05229             return SetData(nFrameID, nTimestamp, audioMD.DataSize(), audioMD.Data());
05230         }
05231 
05237         inline XnStatus SetData(const AudioMetaData& audioMD)
05238         {
05239             return SetData(audioMD, audioMD.FrameID(), audioMD.Timestamp());
05240         }
05241     };
05242 
05243     class MockRawGenerator : public Generator
05244     {
05245     public:
05246         MockRawGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {}
05247         MockRawGenerator(const NodeWrapper& other) : Generator(other) {}
05248 
05249         inline XnStatus Create(Context& context, const XnChar* strName = NULL);
05250 
05251         inline XnStatus SetData(XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize, const void* pData)
05252         {
05253             return xnMockRawSetData(GetHandle(), nFrameID, nTimestamp, nDataSize, pData);
05254         }
05255 
05256     };
05257 
05262     class Codec : public ProductionNode
05263     {
05264     public:
05270         inline Codec(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {}
05271         inline Codec(const NodeWrapper& other) : ProductionNode(other) {}
05272 
05276         inline XnStatus Create(Context& context, XnCodecID codecID, ProductionNode& initializerNode);
05277 
05281         inline XnCodecID GetCodecID() const
05282         {
05283             return xnGetCodecID(GetHandle());
05284         }
05285 
05289         inline XnStatus EncodeData(const void* pSrc, XnUInt32 nSrcSize, void* pDst, XnUInt32 nDstSize, XnUInt* pnBytesWritten) const
05290         {
05291             return xnEncodeData(GetHandle(), pSrc, nSrcSize, pDst, nDstSize, pnBytesWritten);
05292         }
05293 
05297         inline XnStatus DecodeData(const void* pSrc, XnUInt32 nSrcSize, void* pDst, XnUInt32 nDstSize, XnUInt* pnBytesWritten) const
05298         {
05299             return xnDecodeData(GetHandle(), pSrc, nSrcSize, pDst, nDstSize, pnBytesWritten);
05300         }
05301     };
05302 
05307     class ScriptNode : public ProductionNode
05308     {
05309     public:
05315         inline ScriptNode(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {}
05316         inline ScriptNode(const NodeWrapper& other) : ProductionNode(other) {}
05317 
05318         inline XnStatus Create(Context& context, const XnChar* strFormat);
05319 
05320         inline const XnChar* GetSupportedFormat()
05321         {
05322             return xnScriptNodeGetSupportedFormat(GetHandle());
05323         }
05324 
05325         inline XnStatus LoadScriptFromFile(const XnChar* strFileName)
05326         {
05327             return xnLoadScriptFromFile(GetHandle(), strFileName);
05328         }
05329 
05330         inline XnStatus LoadScriptFromString(const XnChar* strScript)
05331         {
05332             return xnLoadScriptFromString(GetHandle(), strScript);
05333         }
05334 
05335         inline XnStatus Run(EnumerationErrors* pErrors);
05336     };
05337 
05338     //---------------------------------------------------------------------------
05339     // EnumerationErrors
05340     //---------------------------------------------------------------------------
05345     class EnumerationErrors
05346     {
05347     public:
05349         inline EnumerationErrors() : m_bAllocated(TRUE), m_pErrors(NULL) { xnEnumerationErrorsAllocate(&m_pErrors); }
05350 
05357         inline EnumerationErrors(XnEnumerationErrors* pErrors, XnBool bOwn = FALSE) : m_bAllocated(bOwn), m_pErrors(pErrors) {}
05358 
05360         ~EnumerationErrors() { Free(); }
05361 
05363         class Iterator
05364         {
05365         public:
05366             friend class EnumerationErrors;
05367 
05373             XnBool operator==(const Iterator& other) const
05374             {
05375                 return m_it == other.m_it;
05376             }
05377 
05383             XnBool operator!=(const Iterator& other) const
05384             {
05385                 return m_it != other.m_it;
05386             }
05387 
05392             inline Iterator& operator++()
05393             {
05394                 m_it = xnEnumerationErrorsGetNext(m_it);
05395                 return *this;
05396             }
05397 
05402             inline Iterator operator++(int)
05403             {
05404                 return Iterator(xnEnumerationErrorsGetNext(m_it));
05405             }
05406 
05408             inline const XnProductionNodeDescription& Description() { return *xnEnumerationErrorsGetCurrentDescription(m_it); }
05410             inline XnStatus Error() { return xnEnumerationErrorsGetCurrentError(m_it); }
05411 
05412         private:
05413             inline Iterator(XnEnumerationErrorsIterator it) : m_it(it) {}
05414 
05415             XnEnumerationErrorsIterator m_it;
05416         };
05417 
05419         inline Iterator Begin() const { return Iterator(xnEnumerationErrorsGetFirst(m_pErrors)); } 
05421         inline Iterator End() const { return Iterator(NULL); } 
05422 
05426         inline XnStatus ToString(XnChar* csBuffer, XnUInt32 nSize)
05427         {
05428             return xnEnumerationErrorsToString(m_pErrors, csBuffer, nSize);
05429         }
05430 
05434         inline void Free()
05435         {
05436             if (m_bAllocated)
05437             {
05438                 xnEnumerationErrorsFree(m_pErrors);
05439                 m_pErrors = NULL;
05440                 m_bAllocated = FALSE;
05441             }
05442         }
05443 
05445         inline XnEnumerationErrors* GetUnderlying() { return m_pErrors; }
05446 
05447     private:
05448         XnEnumerationErrors* m_pErrors;
05449         XnBool m_bAllocated;
05450     };
05451 
05452     //---------------------------------------------------------------------------
05453     // Context
05454     //---------------------------------------------------------------------------
05455 
05460     class Context
05461     {
05462     public:
05464         inline Context() : m_pContext(NULL), m_bUsingDeprecatedAPI(FALSE), m_bAllocated(FALSE), m_hShuttingDownCallback(NULL) {}
05465 
05471         inline Context(XnContext* pContext) : m_pContext(NULL), m_bUsingDeprecatedAPI(FALSE), m_bAllocated(FALSE), m_hShuttingDownCallback(NULL)
05472         {
05473             SetHandle(pContext);
05474         }
05475 
05482         inline Context(const Context& other) : m_pContext(NULL), m_bUsingDeprecatedAPI(FALSE), m_bAllocated(FALSE), m_hShuttingDownCallback(NULL)
05483         {
05484             SetHandle(other.m_pContext);
05485         }
05486 
05488         ~Context() 
05489         { 
05490             SetHandle(NULL);
05491         }
05492 
05493         inline Context& operator=(const Context& other)
05494         {
05495             SetHandle(other.m_pContext);
05496             return *this;
05497         }
05498 
05500         inline XnContext* GetUnderlyingObject() const { return m_pContext; }
05501 
05505         inline XnStatus Init()
05506         {
05507             XnContext* pContext = NULL;
05508             XnStatus nRetVal = xnInit(&pContext);
05509             XN_IS_STATUS_OK(nRetVal);
05510 
05511             TakeOwnership(pContext);
05512             m_bAllocated = TRUE;
05513 
05514             return (XN_STATUS_OK);
05515         }
05516 
05520         inline XnStatus XN_API_DEPRECATED("Use other overload!") RunXmlScript(const XnChar* strScript, EnumerationErrors* pErrors = NULL)
05521         {
05522             m_bUsingDeprecatedAPI = TRUE;
05523             #pragma warning (push)
05524             #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
05525             return xnContextRunXmlScript(m_pContext, strScript, pErrors == NULL ? NULL : pErrors->GetUnderlying());
05526             #pragma warning (pop)
05527         }
05528 
05532         inline XnStatus RunXmlScript(const XnChar* strScript, ScriptNode& scriptNode, EnumerationErrors* pErrors = NULL)
05533         {
05534             XnStatus nRetVal = XN_STATUS_OK;
05535             
05536             XnNodeHandle hScriptNode;
05537             nRetVal = xnContextRunXmlScriptEx(m_pContext, strScript, pErrors == NULL ? NULL : pErrors->GetUnderlying(), &hScriptNode);
05538             XN_IS_STATUS_OK(nRetVal);
05539 
05540             scriptNode.TakeOwnership(hScriptNode);
05541             
05542             return (XN_STATUS_OK);
05543         }
05544 
05548         inline XnStatus XN_API_DEPRECATED("Use other overload!") RunXmlScriptFromFile(const XnChar* strFileName, EnumerationErrors* pErrors = NULL)
05549         {
05550             m_bUsingDeprecatedAPI = TRUE;
05551             #pragma warning (push)
05552             #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
05553             return xnContextRunXmlScriptFromFile(m_pContext, strFileName, pErrors == NULL ? NULL : pErrors->GetUnderlying());
05554             #pragma warning (pop)
05555         }
05556 
05560         inline XnStatus RunXmlScriptFromFile(const XnChar* strFileName, ScriptNode& scriptNode, EnumerationErrors* pErrors = NULL)
05561         {
05562             XnStatus nRetVal = XN_STATUS_OK;
05563 
05564             XnNodeHandle hScriptNode;
05565             nRetVal = xnContextRunXmlScriptFromFileEx(m_pContext, strFileName, pErrors == NULL ? NULL : pErrors->GetUnderlying(), &hScriptNode);
05566             XN_IS_STATUS_OK(nRetVal);
05567 
05568             scriptNode.TakeOwnership(hScriptNode);
05569 
05570             return (XN_STATUS_OK);
05571         }
05572 
05576         inline XnStatus XN_API_DEPRECATED("Use other overload!") InitFromXmlFile(const XnChar* strFileName, EnumerationErrors* pErrors = NULL)
05577         {
05578             XnContext* pContext = NULL;
05579             m_bUsingDeprecatedAPI = TRUE;
05580 
05581             #pragma warning (push)
05582             #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
05583             XnStatus nRetVal = xnInitFromXmlFile(strFileName, &pContext, pErrors == NULL ? NULL : pErrors->GetUnderlying());
05584             #pragma warning (pop)
05585             XN_IS_STATUS_OK(nRetVal);
05586 
05587             TakeOwnership(pContext);
05588             m_bAllocated = TRUE;
05589 
05590             return (XN_STATUS_OK);
05591         }
05592 
05596         inline XnStatus InitFromXmlFile(const XnChar* strFileName, ScriptNode& scriptNode, EnumerationErrors* pErrors = NULL)
05597         {
05598             XnContext* pContext = NULL;
05599 
05600             XnNodeHandle hScriptNode;
05601             XnStatus nRetVal = xnInitFromXmlFileEx(strFileName, &pContext, pErrors == NULL ? NULL : pErrors->GetUnderlying(), &hScriptNode);
05602             XN_IS_STATUS_OK(nRetVal);
05603 
05604             scriptNode.TakeOwnership(hScriptNode);
05605             TakeOwnership(pContext);
05606             m_bAllocated = TRUE;
05607 
05608             return (XN_STATUS_OK);
05609         }
05610 
05614         inline XnStatus XN_API_DEPRECATED("Use other overload!") OpenFileRecording(const XnChar* strFileName)
05615         {
05616             m_bUsingDeprecatedAPI = TRUE;
05617             #pragma warning (push)
05618             #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
05619             return xnContextOpenFileRecording(m_pContext, strFileName);
05620             #pragma warning (pop)
05621         }
05622 
05626         inline XnStatus OpenFileRecording(const XnChar* strFileName, ProductionNode& playerNode)
05627         {
05628             XnStatus nRetVal = XN_STATUS_OK;
05629             
05630             XnNodeHandle hPlayer;
05631             nRetVal = xnContextOpenFileRecordingEx(m_pContext, strFileName, &hPlayer);
05632             XN_IS_STATUS_OK(nRetVal);
05633 
05634             playerNode.TakeOwnership(hPlayer);
05635             
05636             return (XN_STATUS_OK);
05637         }
05638 
05642         inline XnStatus CreateMockNode(XnProductionNodeType type, const XnChar* strName, ProductionNode& mockNode)
05643         {
05644             XnStatus nRetVal = XN_STATUS_OK;
05645             
05646             XnNodeHandle hMockNode;
05647             nRetVal = xnCreateMockNode(m_pContext, type, strName, &hMockNode);
05648             XN_IS_STATUS_OK(nRetVal);
05649 
05650             mockNode.TakeOwnership(hMockNode);
05651             
05652             return (XN_STATUS_OK);
05653         }
05654 
05658         inline XnStatus CreateMockNodeBasedOn(ProductionNode& originalNode, const XnChar* strName, ProductionNode& mockNode)
05659         {
05660             XnStatus nRetVal = XN_STATUS_OK;
05661 
05662             XnNodeHandle hMockNode;
05663             nRetVal = xnCreateMockNodeBasedOn(m_pContext, originalNode, strName, &hMockNode);
05664             XN_IS_STATUS_OK(nRetVal);
05665 
05666             mockNode.TakeOwnership(hMockNode);
05667 
05668             return (XN_STATUS_OK);
05669         }
05670 
05674         inline XnStatus CreateCodec(XnCodecID codecID, ProductionNode& initializerNode, Codec& codec)
05675         {
05676             XnStatus nRetVal = XN_STATUS_OK;
05677 
05678             XnNodeHandle hCodec;
05679             nRetVal =  xnCreateCodec(m_pContext, codecID, initializerNode.GetHandle(), &hCodec);
05680             XN_IS_STATUS_OK(nRetVal);
05681 
05682             codec.TakeOwnership(hCodec);
05683 
05684             return (XN_STATUS_OK);
05685         }
05686 
05690         inline XnStatus AddRef()
05691         {
05692             return xnContextAddRef(m_pContext);
05693         }
05694 
05698         inline void Release()
05699         {
05700             SetHandle(NULL);
05701         }
05702 
05706         inline void XN_API_DEPRECATED("You may use Release() instead, or count on dtor") Shutdown()
05707         {
05708             if (m_pContext != NULL)
05709             {
05710                 #pragma warning (push)
05711                 #pragma warning (disable: XN_DEPRECATED_WARNING_IDS)
05712                 xnShutdown(m_pContext);
05713                 #pragma warning (pop)
05714                 m_pContext = NULL;
05715             }
05716         }
05717 
05721         inline XnStatus AddLicense(const XnLicense& License)
05722         {
05723             return xnAddLicense(m_pContext, &License);
05724         }
05725 
05729         inline XnStatus EnumerateLicenses(XnLicense*& aLicenses, XnUInt32& nCount) const
05730         {
05731             return xnEnumerateLicenses(m_pContext, &aLicenses, &nCount);
05732         }
05733 
05737         inline static void FreeLicensesList(XnLicense aLicenses[])
05738         {
05739             xnFreeLicensesList(aLicenses);
05740         }
05741 
05745         XnStatus EnumerateProductionTrees(XnProductionNodeType Type, const Query* pQuery, NodeInfoList& TreesList, EnumerationErrors* pErrors = NULL) const
05746         {
05747             XnStatus nRetVal = XN_STATUS_OK;
05748 
05749             const XnNodeQuery* pInternalQuery = (pQuery != NULL) ? pQuery->GetUnderlyingObject() : NULL;
05750 
05751             XnNodeInfoList* pList = NULL;
05752             nRetVal = xnEnumerateProductionTrees(m_pContext, Type, pInternalQuery, &pList, pErrors == NULL ? NULL : pErrors->GetUnderlying());
05753             XN_IS_STATUS_OK(nRetVal);
05754 
05755             TreesList.ReplaceUnderlyingObject(pList);
05756 
05757             return (XN_STATUS_OK);
05758         }
05759 
05763         XnStatus CreateAnyProductionTree(XnProductionNodeType type, Query* pQuery, ProductionNode& node, EnumerationErrors* pErrors = NULL)
05764         {
05765             XnStatus nRetVal = XN_STATUS_OK;
05766             
05767             XnNodeQuery* pInternalQuery = (pQuery != NULL) ? pQuery->GetUnderlyingObject() : NULL;
05768 
05769             XnNodeHandle hNode;
05770             nRetVal = xnCreateAnyProductionTree(m_pContext, type, pInternalQuery, &hNode, pErrors == NULL ? NULL : pErrors->GetUnderlying());
05771             XN_IS_STATUS_OK(nRetVal);
05772 
05773             node.TakeOwnership(hNode);
05774 
05775             return (XN_STATUS_OK);
05776         }
05777 
05781         XnStatus XN_API_DEPRECATED("Please use other overload") CreateProductionTree(NodeInfo& Tree)
05782         {
05783             XnStatus nRetVal = XN_STATUS_OK;
05784 
05785             XnNodeHandle hNode;
05786             nRetVal = xnCreateProductionTree(m_pContext, Tree, &hNode);
05787             XN_IS_STATUS_OK(nRetVal);
05788 
05789             Tree.m_bOwnerOfNode = TRUE;
05790 
05791             return (XN_STATUS_OK);
05792         }
05793 
05797         XnStatus CreateProductionTree(NodeInfo& Tree, ProductionNode& node)
05798         {
05799             XnStatus nRetVal = XN_STATUS_OK;
05800 
05801             XnNodeHandle hNode;
05802             nRetVal = xnCreateProductionTree(m_pContext, Tree, &hNode);
05803             XN_IS_STATUS_OK(nRetVal);
05804 
05805             node.TakeOwnership(hNode);
05806 
05807             return (XN_STATUS_OK);
05808         }
05809 
05813         XnStatus EnumerateExistingNodes(NodeInfoList& list) const
05814         {
05815             XnNodeInfoList* pList;
05816             XnStatus nRetVal = xnEnumerateExistingNodes(m_pContext, &pList);
05817             XN_IS_STATUS_OK(nRetVal);
05818 
05819             list.ReplaceUnderlyingObject(pList);
05820 
05821             return (XN_STATUS_OK);
05822         }
05823 
05827         XnStatus EnumerateExistingNodes(NodeInfoList& list, XnProductionNodeType type) const
05828         {
05829             XnNodeInfoList* pList;
05830             XnStatus nRetVal = xnEnumerateExistingNodesByType(m_pContext, type, &pList);
05831             XN_IS_STATUS_OK(nRetVal);
05832 
05833             list.ReplaceUnderlyingObject(pList);
05834 
05835             return (XN_STATUS_OK);
05836         }
05837 
05841         XnStatus FindExistingNode(XnProductionNodeType type, ProductionNode& node) const
05842         {
05843             XnStatus nRetVal = XN_STATUS_OK;
05844 
05845             XnNodeHandle hNode;
05846             nRetVal = xnFindExistingRefNodeByType(m_pContext, type, &hNode);
05847             XN_IS_STATUS_OK(nRetVal);
05848 
05849             node.TakeOwnership(hNode);
05850 
05851             return (XN_STATUS_OK);
05852         }
05853 
05857         XnStatus GetProductionNodeByName(const XnChar* strInstanceName, ProductionNode& node) const
05858         {
05859             XnStatus nRetVal = XN_STATUS_OK;
05860 
05861             XnNodeHandle hNode;
05862             nRetVal = xnGetRefNodeHandleByName(m_pContext, strInstanceName, &hNode);
05863             XN_IS_STATUS_OK(nRetVal);
05864 
05865             node.TakeOwnership(hNode);
05866 
05867             return (XN_STATUS_OK);
05868         }
05869 
05873         XnStatus GetProductionNodeInfoByName(const XnChar* strInstanceName, NodeInfo& nodeInfo) const
05874         {
05875             XnStatus nRetVal = XN_STATUS_OK;
05876 
05877             XnNodeHandle hNode;
05878             nRetVal = xnGetRefNodeHandleByName(m_pContext, strInstanceName, &hNode);
05879             XN_IS_STATUS_OK(nRetVal);
05880 
05881             xnProductionNodeRelease(hNode);
05882 
05883             nodeInfo = NodeInfo(xnGetNodeInfo(hNode));
05884 
05885             return (XN_STATUS_OK);
05886         }
05887 
05891         inline XnStatus StartGeneratingAll()
05892         {
05893             return xnStartGeneratingAll(m_pContext);
05894         }
05895 
05899         inline XnStatus StopGeneratingAll()
05900         {
05901             return xnStopGeneratingAll(m_pContext);
05902         }
05903 
05907         inline XnStatus SetGlobalMirror(XnBool bMirror)
05908         {
05909             return xnSetGlobalMirror(m_pContext, bMirror);
05910         }
05911 
05915         inline XnBool GetGlobalMirror()
05916         {
05917             return xnGetGlobalMirror(m_pContext);
05918         }
05919 
05923         inline XnStatus GetGlobalErrorState()
05924         {
05925             return xnGetGlobalErrorState(m_pContext);
05926         }
05927 
05931         inline XnStatus RegisterToErrorStateChange(XnErrorStateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
05932         {
05933             return xnRegisterToGlobalErrorStateChange(m_pContext, handler, pCookie, &hCallback);
05934         }
05935 
05939         inline void UnregisterFromErrorStateChange(XnCallbackHandle hCallback)
05940         {
05941             xnUnregisterFromGlobalErrorStateChange(m_pContext, hCallback);
05942         }
05943 
05947         inline XnStatus WaitAndUpdateAll()
05948         {
05949             return xnWaitAndUpdateAll(m_pContext);
05950         }
05951 
05955         inline XnStatus WaitAnyUpdateAll()
05956         {
05957             return xnWaitAnyUpdateAll(m_pContext);
05958         }
05959 
05963         inline XnStatus WaitOneUpdateAll(ProductionNode& node)
05964         {
05965             return xnWaitOneUpdateAll(m_pContext, node.GetHandle());
05966         }
05967 
05971         inline XnStatus WaitNoneUpdateAll()
05972         {
05973             return xnWaitNoneUpdateAll(m_pContext);
05974         }
05975 
05979         inline XnStatus AutoEnumerateOverSingleInput(NodeInfoList& List, XnProductionNodeDescription& description, const XnChar* strCreationInfo, XnProductionNodeType InputType, EnumerationErrors* pErrors, Query* pQuery = NULL) const
05980         {
05981             return xnAutoEnumerateOverSingleInput(m_pContext, List.GetUnderlyingObject(), &description, strCreationInfo, InputType, pErrors == NULL ? NULL : pErrors->GetUnderlying(), pQuery == NULL ? NULL : pQuery->GetUnderlyingObject());
05982         }
05983 
05985         inline void SetHandle(XnContext* pContext)
05986         {
05987             if (m_pContext == pContext)
05988             {
05989                 return;
05990             }
05991 
05992             if (m_pContext != NULL)
05993             {
05994                 if (m_bUsingDeprecatedAPI && m_bAllocated)
05995                 {
05996                     // Backwards compatibility: call shutdown instead of release, to make old programs get the 
05997                     // exact same behavior they used to have.
05998                     xnForceShutdown(m_pContext);
05999                 }
06000                 else
06001                 {
06002                     xnContextUnregisterFromShutdown(m_pContext, m_hShuttingDownCallback);
06003                     xnContextRelease(m_pContext);
06004                 }
06005             }
06006 
06007             if (pContext != NULL)
06008             {
06009                 XnStatus nRetVal = xnContextAddRef(pContext);
06010                 XN_ASSERT(nRetVal == XN_STATUS_OK);
06011 
06012                 nRetVal = xnContextRegisterForShutdown(pContext, ContextShuttingDownCallback, this, &m_hShuttingDownCallback);
06013                 XN_ASSERT(nRetVal == XN_STATUS_OK);
06014             }
06015 
06016             m_pContext = pContext;
06017         }
06018 
06019         inline void TakeOwnership(XnContext* pContext)
06020         {
06021             SetHandle(pContext);
06022 
06023             if (pContext != NULL)
06024             {
06025                 xnContextRelease(pContext);
06026             }
06027         }
06028 
06029     private:
06030         static void XN_CALLBACK_TYPE ContextShuttingDownCallback(XnContext* /*pContext*/, void* pCookie)
06031         {
06032             Context* pThis = (Context*)pCookie;
06033             pThis->m_pContext = NULL;
06034         }
06035 
06036         XnContext* m_pContext;
06037         XnBool m_bUsingDeprecatedAPI;
06038         XnBool m_bAllocated;
06039         XnCallbackHandle m_hShuttingDownCallback;
06040     };
06041 
06046     class Resolution
06047     {
06048     public:
06054         inline Resolution(XnResolution res) : m_Res(res)
06055         {
06056             m_nXRes = xnResolutionGetXRes(res);
06057             m_nYRes = xnResolutionGetYRes(res);
06058             m_strName = xnResolutionGetName(res);
06059         }
06060 
06067         inline Resolution(XnUInt32 xRes, XnUInt32 yRes) : m_nXRes(xRes), m_nYRes(yRes)
06068         {
06069             m_Res = xnResolutionGetFromXYRes(xRes, yRes);
06070             m_strName = xnResolutionGetName(m_Res);
06071         }
06072 
06078         inline Resolution(const XnChar* strName)
06079         {
06080             m_Res = xnResolutionGetFromName(strName);
06081             m_nXRes = xnResolutionGetXRes(m_Res);
06082             m_nYRes = xnResolutionGetYRes(m_Res);
06083             m_strName = xnResolutionGetName(m_Res);
06084         }
06085 
06087         inline XnResolution GetResolution() const { return m_Res; }
06089         inline XnUInt32 GetXResolution() const { return m_nXRes; }
06091         inline XnUInt32 GetYResolution() const { return m_nYRes; }
06093         inline const XnChar* GetName() const { return m_strName; }
06094 
06095     private:
06096         XnResolution m_Res;
06097         XnUInt32 m_nXRes;
06098         XnUInt32 m_nYRes;
06099         const XnChar* m_strName;
06100     };
06101 
06102     //---------------------------------------------------------------------------
06103     // Functions Implementation
06104     //---------------------------------------------------------------------------
06105     inline XnStatus NodeInfoList::FilterList(Context& context, Query& query)
06106     {
06107         return xnNodeQueryFilterList(context.GetUnderlyingObject(), query.GetUnderlyingObject(), m_pList);
06108     }
06109 
06110     inline void ProductionNode::GetContext(Context& context) const
06111     {
06112         context.TakeOwnership(xnGetRefContextFromNodeHandle(GetHandle()));
06113     }
06114 
06115     inline NodeInfoList& NodeInfo::GetNeededNodes() const
06116     {
06117         if (m_pNeededNodes == NULL)
06118         {
06119             XnNodeInfoList* pList = xnNodeInfoGetNeededNodes(m_pInfo);
06120             m_pNeededNodes = XN_NEW(NodeInfoList, pList);
06121         }
06122 
06123         return *m_pNeededNodes;
06124     }
06125 
06126     inline void NodeInfo::SetUnderlyingObject(XnNodeInfo* pInfo)
06127     {
06128         if (m_pNeededNodes != NULL)
06129         {
06130             XN_DELETE(m_pNeededNodes);
06131         }
06132 
06133         m_bOwnerOfNode = FALSE;
06134         m_pInfo = pInfo;
06135         m_pNeededNodes = NULL;
06136     }
06137 
06138     inline XnBool FrameSyncCapability::CanFrameSyncWith(Generator& other) const
06139     {
06140         return xnCanFrameSyncWith(GetHandle(), other.GetHandle());
06141     }
06142 
06143     inline XnStatus FrameSyncCapability::FrameSyncWith(Generator& other)
06144     {
06145         return xnFrameSyncWith(GetHandle(), other.GetHandle());
06146     }
06147 
06148     inline XnStatus FrameSyncCapability::StopFrameSyncWith(Generator& other)
06149     {
06150         return xnStopFrameSyncWith(GetHandle(), other.GetHandle());
06151     }
06152 
06153     inline XnBool FrameSyncCapability::IsFrameSyncedWith(Generator& other) const
06154     {
06155         return xnIsFrameSyncedWith(GetHandle(), other.GetHandle());
06156     }
06157 
06158     inline XnStatus NodeInfo::GetInstance(ProductionNode& node) const
06159     {
06160         if (m_pInfo == NULL)
06161         {
06162             return XN_STATUS_INVALID_OPERATION;
06163         }
06164 
06165         XnNodeHandle hNode = xnNodeInfoGetRefHandle(m_pInfo);
06166         node.TakeOwnership(hNode);
06167 
06168         if (m_bOwnerOfNode)
06169         {
06170             xnProductionNodeRelease(hNode);
06171         }
06172 
06173         return (XN_STATUS_OK);
06174     }
06175 
06176     //---------------------------------------------------------------------------
06177     // Node creation functions
06178     //---------------------------------------------------------------------------
06179 
06180     inline XnStatus Device::Create(Context& context, Query* pQuery/*=NULL*/, EnumerationErrors* pErrors/*=NULL*/)
06181     {
06182         XnNodeHandle hNode;
06183         XnStatus nRetVal = xnCreateDevice(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06184         XN_IS_STATUS_OK(nRetVal);
06185         TakeOwnership(hNode);
06186         return (XN_STATUS_OK);
06187     }
06188 
06189     inline XnStatus Recorder::Create(Context& context, const XnChar* strFormatName /*= NULL*/)
06190     {
06191         XnNodeHandle hNode;
06192         XnStatus nRetVal = xnCreateRecorder(context.GetUnderlyingObject(), strFormatName, &hNode);
06193         XN_IS_STATUS_OK(nRetVal);
06194         TakeOwnership(hNode);
06195         return (XN_STATUS_OK);
06196     }
06197 
06198     inline XnStatus Player::Create(Context& context, const XnChar* strFormatName)
06199     {
06200         XnNodeHandle hNode;
06201         XnStatus nRetVal = xnCreatePlayer(context.GetUnderlyingObject(), strFormatName, &hNode);
06202         XN_IS_STATUS_OK(nRetVal);
06203         TakeOwnership(hNode);
06204         return (XN_STATUS_OK);
06205     }
06206 
06207     inline XnStatus DepthGenerator::Create(Context& context, Query* pQuery/*=NULL*/, EnumerationErrors* pErrors/*=NULL*/)
06208     {
06209         XnNodeHandle hNode;
06210         XnStatus nRetVal = xnCreateDepthGenerator(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06211         XN_IS_STATUS_OK(nRetVal);
06212         TakeOwnership(hNode);
06213         return (XN_STATUS_OK);
06214     }
06215 
06216     inline XnStatus MockDepthGenerator::Create(Context& context, const XnChar* strName /* = NULL */)
06217     {
06218         XnNodeHandle hNode;
06219         XnStatus nRetVal = xnCreateMockNode(context.GetUnderlyingObject(), XN_NODE_TYPE_DEPTH, strName, &hNode);
06220         XN_IS_STATUS_OK(nRetVal);
06221         TakeOwnership(hNode);
06222         return (XN_STATUS_OK);
06223     }
06224 
06225     inline XnStatus MockDepthGenerator::CreateBasedOn(DepthGenerator& other, const XnChar* strName /* = NULL */)
06226     {
06227         Context context;
06228         other.GetContext(context);
06229         XnNodeHandle hNode;
06230         XnStatus nRetVal = xnCreateMockNodeBasedOn(context.GetUnderlyingObject(), other.GetHandle(), strName, &hNode);
06231         XN_IS_STATUS_OK(nRetVal);
06232         TakeOwnership(hNode);
06233         return (XN_STATUS_OK);
06234     }
06235 
06236     inline XnStatus ImageGenerator::Create(Context& context, Query* pQuery/*=NULL*/, EnumerationErrors* pErrors/*=NULL*/)
06237     {
06238         XnNodeHandle hNode;
06239         XnStatus nRetVal = xnCreateImageGenerator(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06240         XN_IS_STATUS_OK(nRetVal);
06241         TakeOwnership(hNode);
06242         return (XN_STATUS_OK);
06243     }
06244 
06245     inline XnStatus MockImageGenerator::Create(Context& context, const XnChar* strName /* = NULL */)
06246     {
06247         XnNodeHandle hNode;
06248         XnStatus nRetVal = xnCreateMockNode(context.GetUnderlyingObject(), XN_NODE_TYPE_IMAGE, strName, &hNode);
06249         XN_IS_STATUS_OK(nRetVal);
06250         TakeOwnership(hNode);
06251         return (XN_STATUS_OK);
06252     }
06253 
06254     inline XnStatus MockImageGenerator::CreateBasedOn(ImageGenerator& other, const XnChar* strName /* = NULL */)
06255     {
06256         Context context;
06257         other.GetContext(context);
06258         XnNodeHandle hNode;
06259         XnStatus nRetVal = xnCreateMockNodeBasedOn(context.GetUnderlyingObject(), other.GetHandle(), strName, &hNode);
06260         XN_IS_STATUS_OK(nRetVal);
06261         TakeOwnership(hNode);
06262         return (XN_STATUS_OK);
06263     }
06264 
06265     inline XnStatus IRGenerator::Create(Context& context, Query* pQuery/*=NULL*/, EnumerationErrors* pErrors/*=NULL*/)
06266     {
06267         XnNodeHandle hNode;
06268         XnStatus nRetVal = xnCreateIRGenerator(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06269         XN_IS_STATUS_OK(nRetVal);
06270         TakeOwnership(hNode);
06271         return (XN_STATUS_OK);
06272     }
06273     
06274     inline XnStatus MockIRGenerator::Create(Context& context, const XnChar* strName /* = NULL */)
06275     {
06276         XnNodeHandle hNode;
06277         XnStatus nRetVal = xnCreateMockNode(context.GetUnderlyingObject(), XN_NODE_TYPE_IR, strName, &hNode);
06278         XN_IS_STATUS_OK(nRetVal);
06279         TakeOwnership(hNode);
06280         return (XN_STATUS_OK);
06281     }
06282 
06283     inline XnStatus MockIRGenerator::CreateBasedOn(IRGenerator& other, const XnChar* strName /* = NULL */)
06284     {
06285         Context context;
06286         other.GetContext(context);
06287         XnNodeHandle hNode;
06288         XnStatus nRetVal = xnCreateMockNodeBasedOn(context.GetUnderlyingObject(), other.GetHandle(), strName, &hNode);
06289         XN_IS_STATUS_OK(nRetVal);
06290         TakeOwnership(hNode);
06291         return (XN_STATUS_OK);
06292     }
06293 
06294     inline XnStatus GestureGenerator::Create(Context& context, Query* pQuery/*=NULL*/, EnumerationErrors* pErrors/*=NULL*/)
06295     {
06296         XnNodeHandle hNode;
06297         XnStatus nRetVal = xnCreateGestureGenerator(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06298         XN_IS_STATUS_OK(nRetVal);
06299         TakeOwnership(hNode);
06300         return (XN_STATUS_OK);
06301     }
06302 
06303     inline XnStatus SceneAnalyzer::Create(Context& context, Query* pQuery/*=NULL*/, EnumerationErrors* pErrors/*=NULL*/)
06304     {
06305         //You're creating a scene!
06306         XnNodeHandle hNode;
06307         XnStatus nRetVal = xnCreateSceneAnalyzer(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06308         XN_IS_STATUS_OK(nRetVal);
06309         TakeOwnership(hNode);
06310         return (XN_STATUS_OK);
06311     }
06312 
06313     inline XnStatus HandsGenerator::Create(Context& context, Query* pQuery/*=NULL*/, EnumerationErrors* pErrors/*=NULL*/)
06314     {
06315         XnNodeHandle hNode;
06316         XnStatus nRetVal = xnCreateHandsGenerator(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06317         XN_IS_STATUS_OK(nRetVal);
06318         TakeOwnership(hNode);
06319         return (XN_STATUS_OK);
06320     }
06321 
06322     inline XnStatus UserGenerator::Create(Context& context, Query* pQuery/*=NULL*/, EnumerationErrors* pErrors/*=NULL*/)
06323     {
06324         XnNodeHandle hNode;
06325         XnStatus nRetVal = xnCreateUserGenerator(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06326         XN_IS_STATUS_OK(nRetVal);
06327         TakeOwnership(hNode);
06328         return (XN_STATUS_OK);
06329     }
06330 
06331     inline XnStatus AudioGenerator::Create(Context& context, Query* pQuery/*=NULL*/, EnumerationErrors* pErrors/*=NULL*/)
06332     {
06333         XnNodeHandle hNode;
06334         XnStatus nRetVal = xnCreateAudioGenerator(context.GetUnderlyingObject(), &hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06335         XN_IS_STATUS_OK(nRetVal);
06336         TakeOwnership(hNode);
06337         return (XN_STATUS_OK);
06338     }
06339 
06340     inline XnStatus MockAudioGenerator::Create(Context& context, const XnChar* strName /* = NULL */)
06341     {
06342         XnNodeHandle hNode;
06343         XnStatus nRetVal = xnCreateMockNode(context.GetUnderlyingObject(), XN_NODE_TYPE_AUDIO, strName, &hNode);
06344         XN_IS_STATUS_OK(nRetVal);
06345         TakeOwnership(hNode);
06346         return (XN_STATUS_OK);
06347     }
06348 
06349     inline XnStatus MockAudioGenerator::CreateBasedOn(AudioGenerator& other, const XnChar* strName /* = NULL */)
06350     {
06351         Context context;
06352         other.GetContext(context);
06353         XnNodeHandle hNode;
06354         XnStatus nRetVal = xnCreateMockNodeBasedOn(context.GetUnderlyingObject(), other.GetHandle(), strName, &hNode);
06355         XN_IS_STATUS_OK(nRetVal);
06356         TakeOwnership(hNode);
06357         return (XN_STATUS_OK);
06358     }
06359 
06360     inline XnStatus MockRawGenerator::Create(Context& context, const XnChar* strName /*= NULL*/)
06361     {
06362         XnNodeHandle hNode;
06363         XnStatus nRetVal = xnCreateMockNode(context.GetUnderlyingObject(), XN_NODE_TYPE_GENERATOR, strName, &hNode);
06364         XN_IS_STATUS_OK(nRetVal);
06365         TakeOwnership(hNode);
06366         return (XN_STATUS_OK);
06367     }
06368 
06369     inline XnStatus Codec::Create(Context& context, XnCodecID codecID, ProductionNode& initializerNode)
06370     {
06371         XnNodeHandle hNode;
06372         XnStatus nRetVal = xnCreateCodec(context.GetUnderlyingObject(), codecID, initializerNode.GetHandle(), &hNode);
06373         XN_IS_STATUS_OK(nRetVal);
06374         TakeOwnership(hNode);
06375         return (XN_STATUS_OK);
06376     }
06377 
06378     inline XnStatus ScriptNode::Run(EnumerationErrors* pErrors)
06379     {
06380         return xnScriptNodeRun(GetHandle(), pErrors == NULL ? NULL : pErrors->GetUnderlying());
06381     }
06382 
06383     inline XnStatus ScriptNode::Create(Context& context, const XnChar* strFormat)
06384     {
06385         XnNodeHandle hNode;
06386         XnStatus nRetVal = xnCreateScriptNode(context.GetUnderlyingObject(), strFormat, &hNode);
06387         XN_IS_STATUS_OK(nRetVal);
06388         TakeOwnership(hNode);
06389         return (XN_STATUS_OK);
06390     }
06391 
06392     //---------------------------------------------------------------------------
06393     // Global Helper Functions
06394     //---------------------------------------------------------------------------
06395 
06399     inline void GetVersion(XnVersion& Version)
06400     {
06401         xnGetVersion(&Version);
06402     }
06403 
06404     //---------------------------------------------------------------------------
06405     // Internal Helper Classes and Functions
06406     //---------------------------------------------------------------------------
06407 
06408     class StateChangedCallbackTranslator
06409     {
06410     public:
06411         StateChangedCallbackTranslator(StateChangedHandler handler, void* pCookie) : m_UserHandler(handler), m_pUserCookie(pCookie), m_hCallback(NULL) {}
06412 
06413         XnStatus Register(_XnRegisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode)
06414         {
06415             return xnFunc(hNode, StateChangedCallback, this, &m_hCallback);
06416         }
06417 
06418         void Unregister(_XnUnregisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode)
06419         {
06420             xnFunc(hNode, m_hCallback);
06421         }
06422 
06423         static XnStatus RegisterToUnderlying(_XnRegisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode, StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
06424         {
06425             XnStatus nRetVal = XN_STATUS_OK;
06426             
06427             StateChangedCallbackTranslator* pTrans;
06428             XN_VALIDATE_NEW(pTrans, StateChangedCallbackTranslator, handler, pCookie);
06429 
06430             nRetVal = pTrans->Register(xnFunc, hNode);
06431             if (nRetVal != XN_STATUS_OK)
06432             {
06433                 XN_DELETE(pTrans);
06434                 return (nRetVal);
06435             }
06436 
06437             hCallback = pTrans;
06438             
06439             return (XN_STATUS_OK);
06440         }
06441 
06442         static XnStatus UnregisterFromUnderlying(_XnUnregisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode, XnCallbackHandle hCallback)
06443         {
06444             StateChangedCallbackTranslator* pTrans = (StateChangedCallbackTranslator*)hCallback;
06445             pTrans->Unregister(xnFunc, hNode);
06446             XN_DELETE(pTrans);
06447             return XN_STATUS_OK;
06448         }
06449 
06450     private:
06451         friend class GeneralIntCapability;
06452 
06453         typedef struct StateChangeCookie
06454         {
06455             StateChangedHandler userHandler;
06456             void* pUserCookie;
06457             XnCallbackHandle hCallback;
06458         } StateChangeCookie;
06459 
06460         static void XN_CALLBACK_TYPE StateChangedCallback(XnNodeHandle hNode, void* pCookie)
06461         {
06462             StateChangedCallbackTranslator* pTrans = (StateChangedCallbackTranslator*)pCookie;
06463             ProductionNode node(hNode);
06464             pTrans->m_UserHandler(node, pTrans->m_pUserCookie);
06465         }
06466 
06467         StateChangedHandler m_UserHandler;
06468         void* m_pUserCookie;
06469         XnCallbackHandle m_hCallback;
06470     };
06471 
06472     static XnStatus _RegisterToStateChange(_XnRegisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode, StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
06473     {
06474         return StateChangedCallbackTranslator::RegisterToUnderlying(xnFunc, hNode, handler, pCookie, hCallback);
06475     }
06476 
06477     static void _UnregisterFromStateChange(_XnUnregisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode, XnCallbackHandle hCallback)
06478     {
06479         StateChangedCallbackTranslator::UnregisterFromUnderlying(xnFunc, hNode, hCallback);
06480     }
06481 
06482     inline XnStatus GeneralIntCapability::RegisterToValueChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback)
06483     {
06484         XnStatus nRetVal = XN_STATUS_OK;
06485 
06486         StateChangedCallbackTranslator* pTrans;
06487         XN_VALIDATE_NEW(pTrans, StateChangedCallbackTranslator, handler, pCookie);
06488 
06489         nRetVal = xnRegisterToGeneralIntValueChange(GetHandle(), m_strCap, pTrans->StateChangedCallback, pTrans, &pTrans->m_hCallback);
06490         if (nRetVal != XN_STATUS_OK)
06491         {
06492             XN_DELETE(pTrans);
06493             return (nRetVal);
06494         }
06495 
06496         hCallback = pTrans;
06497 
06498         return (XN_STATUS_OK);
06499     }
06500 
06501     inline void GeneralIntCapability::UnregisterFromValueChange(XnCallbackHandle hCallback)
06502     {
06503         StateChangedCallbackTranslator* pTrans = (StateChangedCallbackTranslator*)hCallback;
06504         xnUnregisterFromGeneralIntValueChange(GetHandle(), m_strCap, pTrans->m_hCallback);
06505         XN_DELETE(pTrans);
06506     }
06507 
06509 };
06510 
06511 #endif // __XN_CPP_WRAPPER_H__