OpenNI 1.0.0
|
00001 /***************************************************************************** 00002 * * 00003 * OpenNI 1.0 Alpha * 00004 * Copyright (C) 2010 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 00023 00024 00025 00026 #ifndef __XN_CPP_WRAPPER_H__ 00027 #define __XN_CPP_WRAPPER_H__ 00028 00029 //--------------------------------------------------------------------------- 00030 // Includes 00031 //--------------------------------------------------------------------------- 00032 #include <XnOpenNI.h> 00033 #include <XnCodecIDs.h> 00034 00035 //--------------------------------------------------------------------------- 00036 // Types 00037 //--------------------------------------------------------------------------- 00038 namespace xn 00039 { 00040 //--------------------------------------------------------------------------- 00041 // Forward Declarations 00042 //--------------------------------------------------------------------------- 00043 class ProductionNode; 00044 class EnumerationErrors; 00045 class NodeInfo; 00046 class NodeInfoList; 00047 class Context; 00048 class Query; 00049 class Generator; 00050 00056 //--------------------------------------------------------------------------- 00057 // Types 00058 //--------------------------------------------------------------------------- 00059 00066 typedef void (XN_CALLBACK_TYPE* StateChangedHandler)(ProductionNode& node, void* pCookie); 00067 00068 //--------------------------------------------------------------------------- 00069 // Internal stuff 00070 //--------------------------------------------------------------------------- 00071 typedef XnStatus (*_XnRegisterStateChangeFuncPtr)(XnNodeHandle hNode, XnStateChangedHandler handler, void* pCookie, XnCallbackHandle* phCallback); 00072 typedef void (*_XnUnregisterStateChangeFuncPtr)(XnNodeHandle hNode, XnCallbackHandle hCallback); 00073 00074 static XnStatus _RegisterToStateChange(_XnRegisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode, StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback); 00075 static void _UnregisterFromStateChange(_XnUnregisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode, XnCallbackHandle hCallback); 00076 00077 //--------------------------------------------------------------------------- 00078 // Meta Data 00079 //--------------------------------------------------------------------------- 00080 00085 class OutputMetaData 00086 { 00087 public: 00093 inline OutputMetaData(const XnUInt8** ppData) : m_ppData(ppData), m_nAllocatedSize(0), m_pAllocatedData(NULL) 00094 { 00095 xnOSMemSet(&m_output, 0, sizeof(XnOutputMetaData)); 00096 } 00097 00101 virtual ~OutputMetaData() { Free(); } 00102 00104 inline XnUInt64 Timestamp() const { return m_output.nTimestamp; } 00106 inline XnUInt64& Timestamp() { return m_output.nTimestamp; } 00107 00109 inline XnUInt32 FrameID() const { return m_output.nFrameID; } 00111 inline XnUInt32& FrameID() { return m_output.nFrameID; } 00112 00114 inline XnUInt32 DataSize() const { return m_output.nDataSize; } 00116 inline XnUInt32& DataSize() { return m_output.nDataSize; } 00117 00119 inline XnBool IsDataNew() const { return m_output.bIsNew; } 00121 inline XnBool& IsDataNew() { return m_output.bIsNew; } 00122 00124 inline const XnOutputMetaData* GetUnderlying() const { return &m_output; } 00126 inline XnOutputMetaData* GetUnderlying() { return &m_output; } 00127 00129 inline const XnUInt8* Data() const { return *m_ppData; } 00131 inline const XnUInt8*& Data() { return *m_ppData; } 00133 inline XnUInt8* WritableData() 00134 { 00135 MakeDataWritable(); 00136 return m_pAllocatedData; 00137 } 00138 00145 XnStatus AllocateData(XnUInt32 nBytes) 00146 { 00147 if (nBytes > m_nAllocatedSize) 00148 { 00149 // reallocate 00150 XnUInt8* pData = (XnUInt8*)xnOSMallocAligned(nBytes, XN_DEFAULT_MEM_ALIGN); 00151 XN_VALIDATE_ALLOC_PTR(pData); 00152 00153 // allocation succeeded, replace 00154 Free(); 00155 m_pAllocatedData = pData; 00156 m_nAllocatedSize = nBytes; 00157 } 00158 00159 DataSize() = nBytes; 00160 *m_ppData = m_pAllocatedData; 00161 00162 return XN_STATUS_OK; 00163 } 00164 00168 void Free() 00169 { 00170 if (m_nAllocatedSize != 0) 00171 { 00172 xnOSFreeAligned(m_pAllocatedData); 00173 m_pAllocatedData = NULL; 00174 m_nAllocatedSize = 0; 00175 } 00176 } 00177 00182 XnStatus MakeDataWritable() 00183 { 00184 XnStatus nRetVal = XN_STATUS_OK; 00185 00186 // check data isn't already writable 00187 if (Data() != m_pAllocatedData || DataSize() > m_nAllocatedSize) 00188 { 00189 const XnUInt8* pOrigData = *m_ppData; 00190 00191 nRetVal = AllocateData(DataSize()); 00192 XN_IS_STATUS_OK(nRetVal); 00193 00194 if (pOrigData != NULL) 00195 { 00196 xnOSMemCopy(m_pAllocatedData, pOrigData, DataSize()); 00197 } 00198 else 00199 { 00200 xnOSMemSet(m_pAllocatedData, 0, DataSize()); 00201 } 00202 } 00203 00204 return (XN_STATUS_OK); 00205 } 00206 00207 protected: 00208 XnUInt8* m_pAllocatedData; 00209 00210 private: 00211 XnOutputMetaData m_output; 00212 00213 const XnUInt8** m_ppData; 00214 XnUInt32 m_nAllocatedSize; 00215 }; 00216 00221 class MapMetaData : public OutputMetaData 00222 { 00223 public: 00230 inline MapMetaData(XnPixelFormat format, const XnUInt8** ppData) : OutputMetaData(ppData) 00231 { 00232 xnOSMemSet(&m_map, 0, sizeof(XnMapMetaData)); 00233 m_map.pOutput = OutputMetaData::GetUnderlying(); 00234 m_map.PixelFormat = format; 00235 } 00236 00238 inline XnUInt32 XRes() const { return m_map.Res.X; } 00240 inline XnUInt32& XRes() { return m_map.Res.X; } 00241 00243 inline XnUInt32 YRes() const { return m_map.Res.Y; } 00245 inline XnUInt32& YRes() { return m_map.Res.Y; } 00246 00248 inline XnUInt32 XOffset() const { return m_map.Offset.X; } 00250 inline XnUInt32& XOffset() { return m_map.Offset.X; } 00251 00253 inline XnUInt32 YOffset() const { return m_map.Offset.Y; } 00255 inline XnUInt32& YOffset() { return m_map.Offset.Y; } 00256 00258 inline XnUInt32 FullXRes() const { return m_map.FullRes.X; } 00260 inline XnUInt32& FullXRes() { return m_map.FullRes.X; } 00261 00263 inline XnUInt32 FullYRes() const { return m_map.FullRes.Y; } 00265 inline XnUInt32& FullYRes() { return m_map.FullRes.Y; } 00266 00268 inline XnUInt32 FPS() const { return m_map.nFPS; } 00270 inline XnUInt32& FPS() { return m_map.nFPS; } 00271 00273 inline XnPixelFormat PixelFormat() const { return m_map.PixelFormat; } 00274 00276 inline const XnMapMetaData* GetUnderlying() const { return &m_map; } 00278 inline XnMapMetaData* GetUnderlying() { return &m_map; } 00279 00281 inline XnUInt32 BytesPerPixel() const 00282 { 00283 switch (PixelFormat()) 00284 { 00285 case XN_PIXEL_FORMAT_RGB24: 00286 return sizeof(XnRGB24Pixel); 00287 case XN_PIXEL_FORMAT_YUV422: 00288 return sizeof(XnYUV422DoublePixel)/2; 00289 case XN_PIXEL_FORMAT_GRAYSCALE_8_BIT: 00290 return sizeof(XnGrayscale8Pixel); 00291 case XN_PIXEL_FORMAT_GRAYSCALE_16_BIT: 00292 return sizeof(XnGrayscale16Pixel); 00293 default: 00294 XN_ASSERT(FALSE); 00295 return 0; 00296 } 00297 } 00298 00305 XnStatus AllocateData(XnUInt32 nXRes, XnUInt32 nYRes) 00306 { 00307 XnStatus nRetVal = XN_STATUS_OK; 00308 00309 XnUInt32 nSize = nXRes * nYRes * BytesPerPixel(); 00310 nRetVal = OutputMetaData::AllocateData(nSize); 00311 XN_IS_STATUS_OK(nRetVal); 00312 00313 FullXRes() = XRes() = nXRes; 00314 FullYRes() = YRes() = nYRes; 00315 XOffset() = YOffset() = 0; 00316 00317 return (XN_STATUS_OK); 00318 } 00319 00328 XnStatus ReAdjust(XnUInt32 nXRes, XnUInt32 nYRes, const XnUInt8* pExternalBuffer) 00329 { 00330 XnStatus nRetVal = XN_STATUS_OK; 00331 00332 if (pExternalBuffer == NULL) 00333 { 00334 nRetVal = AllocateData(nXRes, nYRes); 00335 XN_IS_STATUS_OK(nRetVal); 00336 } 00337 else 00338 { 00339 FullXRes() = XRes() = nXRes; 00340 FullYRes() = YRes() = nYRes; 00341 XOffset() = YOffset() = 0; 00342 Data() = pExternalBuffer; 00343 DataSize() = nXRes * nYRes * BytesPerPixel(); 00344 } 00345 00346 return (XN_STATUS_OK); 00347 } 00348 00349 protected: 00350 XnPixelFormat& PixelFormatImpl() { return m_map.PixelFormat; } 00351 00352 private: 00353 // block copy ctor and assignment operator 00354 MapMetaData& operator=(const MapMetaData&); 00355 inline MapMetaData(const MapMetaData& other); 00356 00357 // Members 00358 XnMapMetaData m_map; 00359 }; 00360 00361 /* Declares a map data accessor class */ 00362 #define _XN_DECLARE_MAP_DATA_CLASS(_name, _pixelType) \ 00363 class _name \ 00364 { \ 00365 public: \ 00366 inline _name(_pixelType*& pData, XnUInt32& nXRes, XnUInt32 &nYRes) : \ 00367 m_pData(pData), m_nXRes(nXRes), m_nYRes(nYRes) {} \ 00368 \ 00369 inline XnUInt32 XRes() const { return m_nXRes; } \ 00370 inline XnUInt32 YRes() const { return m_nYRes; } \ 00371 \ 00372 inline const _pixelType& operator[](XnUInt32 nIndex) const \ 00373 { \ 00374 XN_ASSERT(nIndex < (m_nXRes * m_nYRes)); \ 00375 return m_pData[nIndex]; \ 00376 } \ 00377 inline _pixelType& operator[](XnUInt32 nIndex) \ 00378 { \ 00379 XN_ASSERT(nIndex < (m_nXRes *m_nYRes)); \ 00380 return m_pData[nIndex]; \ 00381 } \ 00382 \ 00383 inline const _pixelType& operator()(XnUInt32 x, XnUInt32 y) const \ 00384 { \ 00385 XN_ASSERT(x < m_nXRes && y < m_nYRes); \ 00386 return m_pData[y*m_nXRes + x]; \ 00387 } \ 00388 inline _pixelType& operator()(XnUInt32 x, XnUInt32 y) \ 00389 { \ 00390 XN_ASSERT(x < m_nXRes && y < m_nYRes); \ 00391 return m_pData[y*m_nXRes + x]; \ 00392 } \ 00393 \ 00394 private: \ 00395 /* block copy ctor and assignment operator */ \ 00396 _name(const _name& other); \ 00397 _name& operator=(const _name&); \ 00398 \ 00399 _pixelType*& m_pData; \ 00400 XnUInt32& m_nXRes; \ 00401 XnUInt32& m_nYRes; \ 00402 }; 00403 00404 _XN_DECLARE_MAP_DATA_CLASS(DepthMap, XnDepthPixel); 00405 _XN_DECLARE_MAP_DATA_CLASS(ImageMap, XnUInt8); 00406 _XN_DECLARE_MAP_DATA_CLASS(RGB24Map, XnRGB24Pixel); 00407 _XN_DECLARE_MAP_DATA_CLASS(Grayscale16Map, XnGrayscale16Pixel); 00408 _XN_DECLARE_MAP_DATA_CLASS(Grayscale8Map, XnGrayscale8Pixel); 00409 _XN_DECLARE_MAP_DATA_CLASS(IRMap, XnIRPixel); 00410 _XN_DECLARE_MAP_DATA_CLASS(LabelMap, XnLabel); 00411 00416 class DepthMetaData : public MapMetaData 00417 { 00418 public: 00422 inline DepthMetaData() : 00423 MapMetaData(XN_PIXEL_FORMAT_GRAYSCALE_16_BIT, (const XnUInt8**)&m_depth.pData), 00424 m_depthMap(const_cast<XnDepthPixel*&>(m_depth.pData), MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y), 00425 m_writableDepthMap((XnDepthPixel*&)m_pAllocatedData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y) 00426 { 00427 xnOSMemSet(&m_depth, 0, sizeof(XnDepthMetaData)); 00428 m_depth.pMap = MapMetaData::GetUnderlying(); 00429 } 00430 00436 inline void InitFrom(const DepthMetaData& other) 00437 { 00438 xnCopyDepthMetaData(&m_depth, &other.m_depth); 00439 } 00440 00450 inline XnStatus InitFrom(const DepthMetaData& other, XnUInt32 nXRes, XnUInt32 nYRes, const XnDepthPixel* pExternalBuffer) 00451 { 00452 InitFrom(other); 00453 return ReAdjust(nXRes, nYRes, pExternalBuffer); 00454 } 00455 00461 XnStatus CopyFrom(const DepthMetaData& other) 00462 { 00463 // copy props 00464 InitFrom(other); 00465 // and make a copy of the data (this will allocate and copy data) 00466 return MakeDataWritable(); 00467 } 00468 00470 XnStatus ReAdjust(XnUInt32 nXRes, XnUInt32 nYRes, const XnDepthPixel* pExternalBuffer = NULL) 00471 { 00472 return MapMetaData::ReAdjust(nXRes, nYRes, (const XnUInt8*)pExternalBuffer); 00473 } 00474 00476 inline XnDepthPixel ZRes() const { return m_depth.nZRes; } 00478 inline XnDepthPixel& ZRes() { return m_depth.nZRes; } 00479 00481 inline const XnDepthPixel* Data() const { return (const XnDepthPixel*)MapMetaData::Data(); } 00483 inline const XnDepthPixel*& Data() { return (const XnDepthPixel*&)MapMetaData::Data(); } 00485 inline XnDepthPixel* WritableData() { return (XnDepthPixel*)MapMetaData::WritableData(); } 00486 00488 inline const xn::DepthMap& DepthMap() const { return m_depthMap; } 00490 inline xn::DepthMap& WritableDepthMap() 00491 { 00492 MakeDataWritable(); 00493 return m_writableDepthMap; 00494 } 00495 00501 inline const XnDepthPixel& operator[](XnUInt32 nIndex) const 00502 { 00503 XN_ASSERT(nIndex < (XRes()*YRes())); 00504 return Data()[nIndex]; 00505 } 00506 00513 inline const XnDepthPixel& operator()(XnUInt32 x, XnUInt32 y) const 00514 { 00515 XN_ASSERT(x < XRes() && y < YRes()); 00516 return Data()[y*XRes() + x]; 00517 } 00518 00520 inline const XnDepthMetaData* GetUnderlying() const { return &m_depth; } 00522 inline XnDepthMetaData* GetUnderlying() { return &m_depth; } 00523 00524 private: 00525 // block copy ctor and assignment operator (because we can't return errors in those) 00526 DepthMetaData(const DepthMetaData& other); 00527 DepthMetaData& operator=(const DepthMetaData&); 00528 00529 XnDepthMetaData m_depth; 00530 const xn::DepthMap m_depthMap; 00531 xn::DepthMap m_writableDepthMap; 00532 }; 00533 00538 class ImageMetaData : public MapMetaData 00539 { 00540 public: 00542 inline ImageMetaData() : 00543 MapMetaData(XN_PIXEL_FORMAT_RGB24, &m_image.pData), 00544 m_imageMap(const_cast<XnUInt8*&>(m_image.pData), MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y), 00545 m_writableImageMap((XnUInt8*&)m_pAllocatedData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y), 00546 m_rgb24Map((XnRGB24Pixel*&)m_image.pData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y), 00547 m_writableRgb24Map((XnRGB24Pixel*&)m_pAllocatedData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y), 00548 m_gray16Map((XnGrayscale16Pixel*&)m_image.pData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y), 00549 m_writableGray16Map((XnGrayscale16Pixel*&)m_pAllocatedData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y), 00550 m_gray8Map((XnGrayscale8Pixel*&)m_image.pData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y), 00551 m_writableGray8Map((XnGrayscale8Pixel*&)m_pAllocatedData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y) 00552 { 00553 xnOSMemSet(&m_image, 0, sizeof(XnImageMetaData)); 00554 m_image.pMap = MapMetaData::GetUnderlying(); 00555 } 00556 00562 inline void InitFrom(const ImageMetaData& other) 00563 { 00564 xnCopyImageMetaData(&m_image, &other.m_image); 00565 } 00566 00577 inline XnStatus InitFrom(const ImageMetaData& other, XnUInt32 nXRes, XnUInt32 nYRes, XnPixelFormat format, const XnUInt8* pExternalBuffer) 00578 { 00579 InitFrom(other); 00580 XnStatus nRetVal = ReAdjust(nXRes, nYRes, format, pExternalBuffer); 00581 XN_IS_STATUS_OK(nRetVal); 00582 PixelFormat() = format; 00583 return XN_STATUS_OK; 00584 } 00585 00593 inline XnStatus AllocateData(XnUInt32 nXRes, XnUInt32 nYRes, XnPixelFormat format) 00594 { 00595 XnPixelFormat origFormat = PixelFormat(); 00596 PixelFormat() = format; 00597 XnStatus nRetVal = MapMetaData::AllocateData(nXRes, nYRes); 00598 if (nRetVal != XN_STATUS_OK) 00599 { 00600 PixelFormat() = origFormat; 00601 return (nRetVal); 00602 } 00603 00604 return XN_STATUS_OK; 00605 } 00606 00608 inline XnStatus CopyFrom(const ImageMetaData& other) 00609 { 00610 // copy props 00611 xnCopyImageMetaData(&m_image, &other.m_image); 00612 // and make a copy of the data (this will allocate and copy data) 00613 return MakeDataWritable(); 00614 } 00615 00625 XnStatus ReAdjust(XnUInt32 nXRes, XnUInt32 nYRes, XnPixelFormat format, const XnUInt8* pExternalBuffer = NULL) 00626 { 00627 XnPixelFormat origFormat = PixelFormat(); 00628 PixelFormat() = format; 00629 XnStatus nRetVal = MapMetaData::ReAdjust(nXRes, nYRes, pExternalBuffer); 00630 if (nRetVal != XN_STATUS_OK) 00631 { 00632 PixelFormat() = origFormat; 00633 return (nRetVal); 00634 } 00635 00636 return XN_STATUS_OK; 00637 } 00638 00640 inline XnPixelFormat PixelFormat() const { return MapMetaData::PixelFormat(); } 00642 inline XnPixelFormat& PixelFormat() { return MapMetaData::PixelFormatImpl(); } 00643 00645 inline XnUInt8* WritableData() { return MapMetaData::WritableData(); } 00646 00648 inline const XnRGB24Pixel* RGB24Data() const { return (const XnRGB24Pixel*)MapMetaData::Data(); } 00650 inline const XnRGB24Pixel*& RGB24Data() { return (const XnRGB24Pixel*&)MapMetaData::Data(); } 00652 inline XnRGB24Pixel* WritableRGB24Data() { return (XnRGB24Pixel*)MapMetaData::WritableData(); } 00653 00655 inline const XnYUV422DoublePixel* YUV422Data() const { return (const XnYUV422DoublePixel*)MapMetaData::Data(); } 00657 inline const XnYUV422DoublePixel*& YUV422Data() { return (const XnYUV422DoublePixel*&)MapMetaData::Data(); } 00659 inline XnYUV422DoublePixel* WritableYUV422Data() { return (XnYUV422DoublePixel*)MapMetaData::WritableData(); } 00660 00662 inline const XnGrayscale8Pixel* Grayscale8Data() const { return (const XnGrayscale8Pixel*)MapMetaData::Data(); } 00664 inline const XnGrayscale8Pixel*& Grayscale8Data() { return (const XnGrayscale8Pixel*&)MapMetaData::Data(); } 00666 inline XnGrayscale8Pixel* WritableGrayscale8Data() { return (XnGrayscale8Pixel*)MapMetaData::WritableData(); } 00667 00669 inline const XnGrayscale16Pixel* Grayscale16Data() const { return (const XnGrayscale16Pixel*)MapMetaData::Data(); } 00671 inline const XnGrayscale16Pixel*& Grayscale16Data() { return (const XnGrayscale16Pixel*&)MapMetaData::Data(); } 00673 inline XnGrayscale16Pixel* WritableGrayscale16Data() { return (XnGrayscale16Pixel*)MapMetaData::WritableData(); } 00674 00676 inline const xn::ImageMap& ImageMap() const { return m_imageMap; } 00678 inline xn::ImageMap& WritableImageMap() { MakeDataWritable(); return m_writableImageMap; } 00679 00681 inline const xn::RGB24Map& RGB24Map() const { return m_rgb24Map; } 00683 inline xn::RGB24Map& WritableRGB24Map() { MakeDataWritable(); return m_writableRgb24Map; } 00684 00686 inline const xn::Grayscale8Map& Grayscale8Map() const { return m_gray8Map; } 00688 inline xn::Grayscale8Map& WritableGrayscale8Map() { MakeDataWritable(); return m_writableGray8Map; } 00689 00691 inline const xn::Grayscale16Map& Grayscale16Map() const { return m_gray16Map; } 00693 inline xn::Grayscale16Map& WritableGrayscale16Map() { MakeDataWritable(); return m_writableGray16Map; } 00694 00696 inline const XnImageMetaData* GetUnderlying() const { return &m_image; } 00698 inline XnImageMetaData* GetUnderlying() { return &m_image; } 00699 00700 private: 00701 // block copy ctor and assignment operator 00702 ImageMetaData(const ImageMetaData& other); 00703 ImageMetaData& operator=(const ImageMetaData&); 00704 00705 XnImageMetaData m_image; 00706 const xn::ImageMap m_imageMap; 00707 xn::ImageMap m_writableImageMap; 00708 const xn::RGB24Map m_rgb24Map; 00709 xn::RGB24Map m_writableRgb24Map; 00710 const xn::Grayscale16Map m_gray16Map; 00711 xn::Grayscale16Map m_writableGray16Map; 00712 const xn::Grayscale8Map m_gray8Map; 00713 xn::Grayscale8Map m_writableGray8Map; 00714 }; 00715 00720 class IRMetaData : public MapMetaData 00721 { 00722 public: 00724 inline IRMetaData() : 00725 MapMetaData(XN_PIXEL_FORMAT_GRAYSCALE_16_BIT, (const XnUInt8**)&m_ir.pData), 00726 m_irMap(const_cast<XnIRPixel*&>(m_ir.pData), MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y), 00727 m_writableIRMap((XnIRPixel*&)m_pAllocatedData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y) 00728 { 00729 xnOSMemSet(&m_ir, 0, sizeof(XnIRMetaData)); 00730 m_ir.pMap = MapMetaData::GetUnderlying(); 00731 } 00732 00738 inline void InitFrom(const IRMetaData& other) 00739 { 00740 xnCopyIRMetaData(&m_ir, &other.m_ir); 00741 } 00742 00744 inline XnStatus InitFrom(const IRMetaData& other, XnUInt32 nXRes, XnUInt32 nYRes, const XnIRPixel* pExternalBuffer) 00745 { 00746 InitFrom(other); 00747 return ReAdjust(nXRes, nYRes, pExternalBuffer); 00748 } 00749 00751 XnStatus CopyFrom(const IRMetaData& other) 00752 { 00753 // copy props 00754 xnCopyIRMetaData(&m_ir, &other.m_ir); 00755 // and make a copy of the data (this will allocate and copy data) 00756 return MakeDataWritable(); 00757 } 00758 00760 XnStatus ReAdjust(XnUInt32 nXRes, XnUInt32 nYRes, const XnIRPixel* pExternalBuffer = NULL) 00761 { 00762 return MapMetaData::ReAdjust(nXRes, nYRes, (const XnUInt8*)pExternalBuffer); 00763 } 00764 00766 inline const XnIRPixel* Data() const { return (const XnIRPixel*)MapMetaData::Data(); } 00768 inline const XnIRPixel*& Data() { return (const XnIRPixel*&)MapMetaData::Data(); } 00770 inline XnIRPixel* WritableData() { return (XnIRPixel*)MapMetaData::WritableData(); } 00771 00773 inline const xn::IRMap& IRMap() const { return m_irMap; } 00775 inline xn::IRMap& WritableIRMap() { MakeDataWritable(); return m_writableIRMap; } 00776 00778 inline const XnIRMetaData* GetUnderlying() const { return &m_ir; } 00780 inline XnIRMetaData* GetUnderlying() { return &m_ir; } 00781 00782 private: 00783 // block copy ctor and assignment operator 00784 IRMetaData(const IRMetaData& other); 00785 IRMetaData& operator=(const IRMetaData&); 00786 00787 XnIRMetaData m_ir; 00788 const xn::IRMap m_irMap; 00789 xn::IRMap m_writableIRMap; 00790 }; 00791 00796 class AudioMetaData : public OutputMetaData 00797 { 00798 public: 00800 inline AudioMetaData() : OutputMetaData(&m_audio.pData) 00801 { 00802 xnOSMemSet(&m_audio, 0, sizeof(XnAudioMetaData)); 00803 m_audio.pOutput = OutputMetaData::GetUnderlying(); 00804 } 00805 00811 inline void InitFrom(const AudioMetaData& other) 00812 { 00813 xnCopyAudioMetaData(&m_audio, &other.m_audio); 00814 } 00815 00817 inline XnUInt8 NumberOfChannels() const { return m_audio.Wave.nChannels; } 00819 inline XnUInt8& NumberOfChannels() { return m_audio.Wave.nChannels; } 00820 00822 inline XnUInt32 SampleRate() const { return m_audio.Wave.nSampleRate; } 00824 inline XnUInt32& SampleRate() { return m_audio.Wave.nSampleRate; } 00825 00827 inline XnUInt16 BitsPerSample() const { return m_audio.Wave.nBitsPerSample; } 00829 inline XnUInt16& BitsPerSample() { return m_audio.Wave.nBitsPerSample; } 00830 00832 inline const XnAudioMetaData* GetUnderlying() const { return &m_audio; } 00834 inline XnAudioMetaData* GetUnderlying() { return &m_audio; } 00835 00836 private: 00837 // block copy ctor and assignment operator 00838 AudioMetaData(const AudioMetaData& other); 00839 AudioMetaData& operator=(const AudioMetaData&); 00840 00841 XnAudioMetaData m_audio; 00842 XnBool m_bAllocated; 00843 }; 00844 00849 class SceneMetaData : public MapMetaData 00850 { 00851 public: 00853 inline SceneMetaData() : 00854 MapMetaData(XN_PIXEL_FORMAT_GRAYSCALE_16_BIT, (const XnUInt8**)&m_scene.pData), 00855 m_labelMap(const_cast<XnLabel*&>(m_scene.pData), MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y), 00856 m_writableLabelMap((XnLabel*&)m_pAllocatedData, MapMetaData::GetUnderlying()->Res.X, MapMetaData::GetUnderlying()->Res.Y) 00857 { 00858 xnOSMemSet(&m_scene, 0, sizeof(XnSceneMetaData)); 00859 m_scene.pMap = MapMetaData::GetUnderlying(); 00860 } 00861 00867 inline void InitFrom(const SceneMetaData& other) 00868 { 00869 xnCopySceneMetaData(&m_scene, &other.m_scene); 00870 } 00871 00873 inline XnStatus InitFrom(const SceneMetaData& other, XnUInt32 nXRes, XnUInt32 nYRes, const XnLabel* pExternalBuffer) 00874 { 00875 InitFrom(other); 00876 return ReAdjust(nXRes, nYRes, pExternalBuffer); 00877 } 00878 00880 XnStatus CopyFrom(const SceneMetaData& other) 00881 { 00882 // copy props 00883 xnCopySceneMetaData(&m_scene, &other.m_scene); 00884 // and make a copy of the data (this will allocate and copy data) 00885 return MakeDataWritable(); 00886 } 00887 00889 XnStatus ReAdjust(XnUInt32 nXRes, XnUInt32 nYRes, const XnLabel* pExternalBuffer = NULL) 00890 { 00891 return MapMetaData::ReAdjust(nXRes, nYRes, (const XnUInt8*)pExternalBuffer); 00892 } 00893 00895 inline const XnLabel* Data() const { return (const XnLabel*)MapMetaData::Data(); } 00897 inline const XnLabel*& Data() { return (const XnLabel*&)MapMetaData::Data(); } 00899 inline XnLabel* WritableData() { return (XnLabel*)MapMetaData::WritableData(); } 00900 00902 inline const xn::LabelMap& LabelMap() const { return m_labelMap; } 00904 inline xn::LabelMap& WritableLabelMap() { MakeDataWritable(); return m_writableLabelMap; } 00905 00911 inline const XnLabel& operator[](XnUInt32 nIndex) const 00912 { 00913 XN_ASSERT(nIndex < (XRes()*YRes())); 00914 return Data()[nIndex]; 00915 } 00916 00923 inline const XnLabel& operator()(XnUInt32 x, XnUInt32 y) const 00924 { 00925 XN_ASSERT(x < XRes() && y < YRes()); 00926 return (*this)[y*XRes() + x]; 00927 } 00928 00930 inline const XnSceneMetaData* GetUnderlying() const { return &m_scene; } 00932 inline XnSceneMetaData* GetUnderlying() { return &m_scene; } 00933 00934 private: 00935 // block copy ctor and assignment operator 00936 SceneMetaData(const SceneMetaData& other); 00937 SceneMetaData& operator=(const SceneMetaData&); 00938 00939 XnSceneMetaData m_scene; 00940 const xn::LabelMap m_labelMap; 00941 xn::LabelMap m_writableLabelMap; 00942 }; 00943 00944 //--------------------------------------------------------------------------- 00945 // NodeWrapper 00946 //--------------------------------------------------------------------------- 00947 00952 class NodeWrapper 00953 { 00954 public: 00955 friend class Context; 00956 00962 inline NodeWrapper(XnNodeHandle hNode) : m_hNode(NULL) 00963 { 00964 NodeWrapper::SetHandle(hNode); 00965 } 00966 00967 inline ~NodeWrapper() 00968 { 00969 } 00970 00972 inline operator XnNodeHandle() const { return m_hNode; } 00973 00979 inline XnBool operator==(const NodeWrapper& other) 00980 { 00981 return (m_hNode == other.m_hNode); 00982 } 00983 00989 inline XnBool operator!=(const NodeWrapper& other) 00990 { 00991 return (m_hNode != other.m_hNode); 00992 } 00993 00995 inline XnBool IsValid() const { return (m_hNode != NULL); } 00996 01000 const XnChar* GetName() const {return xnGetNodeName(m_hNode); } 01001 01005 inline XnStatus AddRef() { return xnProductionNodeAddRef(m_hNode); } 01006 01010 inline void Release() 01011 { 01012 xnProductionNodeRelease(m_hNode); 01013 m_hNode = NULL; 01014 } 01015 01016 inline XnStatus XN_API_DEPRECATED("Please use AddRef() instead.") Ref() { return AddRef(); } 01017 inline void XN_API_DEPRECATED("Please use Release() instead.") Unref() { Release(); } 01018 01020 inline void SetHandle(XnNodeHandle hNode) { m_hNode = hNode; } 01021 01022 protected: 01023 XnNodeHandle m_hNode; 01024 }; 01025 01026 //--------------------------------------------------------------------------- 01027 // Node Info 01028 //--------------------------------------------------------------------------- 01029 01034 class NodeInfo 01035 { 01036 public: 01042 NodeInfo(XnNodeInfo* pInfo) : m_pNeededNodes(NULL) 01043 { 01044 SetUnderlyingObject(pInfo); 01045 } 01046 01052 NodeInfo(const NodeInfo& other) : m_pNeededNodes(NULL) 01053 { 01054 SetUnderlyingObject(other.m_pInfo); 01055 } 01056 01058 ~NodeInfo() 01059 { 01060 SetUnderlyingObject(NULL); 01061 } 01062 01068 inline NodeInfo& operator=(const NodeInfo& other) 01069 { 01070 SetUnderlyingObject(other.m_pInfo); 01071 return *this; 01072 } 01073 01075 inline operator XnNodeInfo*() 01076 { 01077 return m_pInfo; 01078 } 01079 01083 inline XnStatus SetInstanceName(const XnChar* strName) 01084 { 01085 return xnNodeInfoSetInstanceName(m_pInfo, strName); 01086 } 01087 01091 inline const XnProductionNodeDescription& GetDescription() const 01092 { 01093 return *xnNodeInfoGetDescription(m_pInfo); 01094 } 01095 01099 inline const XnChar* GetInstanceName() const 01100 { 01101 return xnNodeInfoGetInstanceName(m_pInfo); 01102 } 01103 inline const XnChar* GetCreationInfo() const 01107 { 01108 return xnNodeInfoGetCreationInfo(m_pInfo); 01109 } 01110 01114 inline NodeInfoList& GetNeededNodes() const; 01115 01123 inline XnStatus GetInstance(ProductionNode& node) const; 01124 01125 private: 01126 inline void SetUnderlyingObject(XnNodeInfo* pInfo); 01127 01128 XnNodeInfo* m_pInfo; 01129 mutable NodeInfoList* m_pNeededNodes; 01130 }; 01131 01132 //--------------------------------------------------------------------------- 01133 // Query 01134 //--------------------------------------------------------------------------- 01135 01141 class Query 01142 { 01143 public: 01145 inline Query() 01146 { 01147 xnNodeQueryAllocate(&m_pQuery); 01148 } 01149 01151 ~Query() 01152 { 01153 xnNodeQueryFree(m_pQuery); 01154 m_pQuery = NULL; 01155 } 01156 01158 inline XnNodeQuery* GetUnderlyingObject() const { return m_pQuery; } 01159 01163 inline XnStatus SetVendor(const XnChar* strVendor) 01164 { 01165 return xnNodeQuerySetVendor(m_pQuery, strVendor); 01166 } 01167 01171 inline XnStatus SetName(const XnChar* strName) 01172 { 01173 return xnNodeQuerySetName(m_pQuery, strName); 01174 } 01175 01179 inline XnStatus SetMinVersion(const XnVersion& minVersion) 01180 { 01181 return xnNodeQuerySetMinVersion(m_pQuery, &minVersion); 01182 } 01183 01187 inline XnStatus SetMaxVersion(const XnVersion& maxVersion) 01188 { 01189 return xnNodeQuerySetMaxVersion(m_pQuery, &maxVersion); 01190 } 01191 01195 inline XnStatus AddSupportedCapability(const XnChar* strNeededCapability) 01196 { 01197 return xnNodeQueryAddSupportedCapability(m_pQuery, strNeededCapability); 01198 } 01199 01203 inline XnStatus AddSupportedMapOutputMode(const XnMapOutputMode& MapOutputMode) 01204 { 01205 return xnNodeQueryAddSupportedMapOutputMode(m_pQuery, &MapOutputMode); 01206 } 01207 01211 inline XnStatus SetSupportedMinUserPositions(const XnUInt32 nCount) 01212 { 01213 return xnNodeQuerySetSupportedMinUserPositions(m_pQuery, nCount); 01214 } 01215 01219 inline XnStatus SetExistingNodeOnly(XnBool bExistingNode) 01220 { 01221 return xnNodeQuerySetExistingNodeOnly(m_pQuery, bExistingNode); 01222 } 01223 01227 inline XnStatus AddNeededNode(const XnChar* strInstanceName) 01228 { 01229 return xnNodeQueryAddNeededNode(m_pQuery, strInstanceName); 01230 } 01231 01235 inline XnStatus SetCreationInfo(const XnChar* strCreationInfo) 01236 { 01237 return xnNodeQuerySetCreationInfo(m_pQuery, strCreationInfo); 01238 } 01239 01240 private: 01241 XnNodeQuery* m_pQuery; 01242 }; 01243 01244 //--------------------------------------------------------------------------- 01245 // Node Info List 01246 //--------------------------------------------------------------------------- 01247 01252 class NodeInfoList 01253 { 01254 public: 01256 class Iterator 01257 { 01258 public: 01259 friend class NodeInfoList; 01260 01266 XnBool operator==(const Iterator& other) const 01267 { 01268 return m_it.pCurrent == other.m_it.pCurrent; 01269 } 01270 01276 XnBool operator!=(const Iterator& other) const 01277 { 01278 return m_it.pCurrent != other.m_it.pCurrent; 01279 } 01280 01285 inline Iterator& operator++() 01286 { 01287 UpdateInternalObject(xnNodeInfoListGetNext(m_it)); 01288 return *this; 01289 } 01290 01295 inline Iterator operator++(int) 01296 { 01297 XnNodeInfoListIterator curr = m_it; 01298 UpdateInternalObject(xnNodeInfoListGetNext(m_it)); 01299 return Iterator(curr); 01300 } 01301 01305 inline Iterator& operator--() 01306 { 01307 UpdateInternalObject(xnNodeInfoListGetPrevious(m_it)); 01308 return *this; 01309 } 01310 01314 inline Iterator operator--(int) 01315 { 01316 XnNodeInfoListIterator curr = m_it; 01317 UpdateInternalObject(xnNodeInfoListGetPrevious(m_it)); 01318 return Iterator(curr); 01319 } 01320 01322 inline NodeInfo operator*() 01323 { 01324 return m_Info; 01325 } 01326 01327 private: 01328 inline Iterator(XnNodeInfoListIterator it) : m_Info(NULL) 01329 { 01330 UpdateInternalObject(it); 01331 } 01332 01333 inline void UpdateInternalObject(XnNodeInfoListIterator it) 01334 { 01335 m_it = it; 01336 if (xnNodeInfoListIteratorIsValid(it)) 01337 { 01338 XnNodeInfo* pInfo = xnNodeInfoListGetCurrent(it); 01339 m_Info = NodeInfo(pInfo); 01340 } 01341 else 01342 { 01343 m_Info = NodeInfo(NULL); 01344 } 01345 } 01346 01347 NodeInfo m_Info; 01348 XnNodeInfoListIterator m_it; 01349 }; 01350 01354 inline NodeInfoList() 01355 { 01356 xnNodeInfoListAllocate(&m_pList); 01357 m_bAllocated = TRUE; 01358 } 01359 01366 inline NodeInfoList(XnNodeInfoList* pList) : m_pList(pList), m_bAllocated(FALSE) {} 01367 01369 inline ~NodeInfoList() 01370 { 01371 FreeImpl(); 01372 } 01373 01375 inline XnNodeInfoList* GetUnderlyingObject() const { return m_pList; } 01376 01383 inline void ReplaceUnderlyingObject(XnNodeInfoList* pList) 01384 { 01385 FreeImpl(); 01386 m_pList = pList; 01387 m_bAllocated = TRUE; 01388 } 01389 01394 inline XnStatus Add(XnProductionNodeDescription& description, const XnChar* strCreationInfo, NodeInfoList* pNeededNodes) 01395 { 01396 XnNodeInfoList* pList = (pNeededNodes == NULL) ? NULL : pNeededNodes->GetUnderlyingObject(); 01397 return xnNodeInfoListAdd(m_pList, &description, strCreationInfo, pList); 01398 } 01399 01403 inline XnStatus AddNode(NodeInfo& info) 01404 { 01405 return xnNodeInfoListAddNode(m_pList, info); 01406 } 01407 01411 inline XnStatus AddNodeFromAnotherList(Iterator& it) 01412 { 01413 return xnNodeInfoListAddNodeFromList(m_pList, it.m_it); 01414 } 01415 01417 inline Iterator Begin() const 01418 { 01419 return Iterator(xnNodeInfoListGetFirst(m_pList)); 01420 } 01421 01423 inline Iterator End() const 01424 { 01425 XnNodeInfoListIterator it = { NULL }; 01426 return Iterator(it); 01427 } 01428 01430 inline Iterator RBegin() const 01431 { 01432 return Iterator(xnNodeInfoListGetLast(m_pList)); 01433 } 01434 01436 inline Iterator REnd() const 01437 { 01438 XnNodeInfoListIterator it = { NULL }; 01439 return Iterator(it); 01440 } 01441 01445 inline XnStatus Remove(Iterator& it) 01446 { 01447 return xnNodeInfoListRemove(m_pList, it.m_it); 01448 } 01449 01453 inline XnStatus Clear() 01454 { 01455 return xnNodeInfoListClear(m_pList); 01456 } 01457 01461 inline XnStatus Append(NodeInfoList& other) 01462 { 01463 return xnNodeInfoListAppend(m_pList, other.GetUnderlyingObject()); 01464 } 01465 01469 inline XnBool IsEmpty() 01470 { 01471 return xnNodeInfoListIsEmpty(m_pList); 01472 } 01473 01477 inline XnStatus FilterList(Context& context, Query& query); 01478 01479 private: 01480 inline void FreeImpl() 01481 { 01482 if (m_bAllocated) 01483 { 01484 xnNodeInfoListFree(m_pList); 01485 m_bAllocated = FALSE; 01486 m_pList = NULL; 01487 } 01488 } 01489 01490 XnNodeInfoList* m_pList; 01491 XnBool m_bAllocated; 01492 }; 01493 01494 //--------------------------------------------------------------------------- 01495 // Production Nodes Functionality 01496 //--------------------------------------------------------------------------- 01497 01502 class Capability 01503 { 01504 public: 01510 Capability(XnNodeHandle hNode) : m_hNode(hNode) {} 01511 01517 inline void SetUnderlyingHandle(XnNodeHandle hNode) 01518 { 01519 m_hNode = hNode; 01520 } 01521 01522 protected: 01523 XnNodeHandle m_hNode; 01524 }; 01525 01530 class ErrorStateCapability : public Capability 01531 { 01532 public: 01538 ErrorStateCapability(XnNodeHandle hNode) : Capability(hNode) {} 01539 01543 inline XnStatus GetErrorState() 01544 { 01545 return xnGetNodeErrorState(m_hNode); 01546 } 01547 01551 inline XnStatus RegisterToErrorStateChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 01552 { 01553 return _RegisterToStateChange(xnRegisterToNodeErrorStateChange, m_hNode, handler, pCookie, hCallback); 01554 } 01555 01559 inline void UnregisterFromErrorStateChange(XnCallbackHandle hCallback) 01560 { 01561 _UnregisterFromStateChange(xnUnregisterFromNodeErrorStateChange, m_hNode, hCallback); 01562 } 01563 }; 01564 01569 class ProductionNode : public NodeWrapper 01570 { 01571 public: 01577 inline ProductionNode(XnNodeHandle hNode = NULL) : NodeWrapper(hNode) {} 01578 01582 inline NodeInfo GetInfo() const { return NodeInfo(xnGetNodeInfo(m_hNode)); } 01583 01587 inline XnStatus AddNeededNode(ProductionNode& needed) 01588 { 01589 return xnAddNeededNode(m_hNode, needed.m_hNode); 01590 } 01591 01595 inline XnStatus RemoveNeededNode(ProductionNode& needed) 01596 { 01597 return xnRemoveNeededNode(m_hNode, needed.m_hNode); 01598 } 01599 01603 inline void GetContext(Context& context); 01604 01608 inline XnBool IsCapabilitySupported(const XnChar* strCapabilityName) const 01609 { 01610 return xnIsCapabilitySupported(m_hNode, strCapabilityName); 01611 } 01612 01616 inline XnStatus SetIntProperty(const XnChar* strName, XnUInt64 nValue) 01617 { 01618 return xnSetIntProperty(m_hNode, strName, nValue); 01619 } 01620 01624 inline XnStatus SetRealProperty(const XnChar* strName, XnDouble dValue) 01625 { 01626 return xnSetRealProperty(m_hNode, strName, dValue); 01627 } 01628 01632 inline XnStatus SetStringProperty(const XnChar* strName, const XnChar* strValue) 01633 { 01634 return xnSetStringProperty(m_hNode, strName, strValue); 01635 } 01636 01640 inline XnStatus SetGeneralProperty(const XnChar* strName, XnUInt32 nBufferSize, const void* pBuffer) 01641 { 01642 return xnSetGeneralProperty(m_hNode, strName, nBufferSize, pBuffer); 01643 } 01644 01648 inline XnStatus GetIntProperty(const XnChar* strName, XnUInt64& nValue) const 01649 { 01650 return xnGetIntProperty(m_hNode, strName, &nValue); 01651 } 01652 01656 inline XnStatus GetRealProperty(const XnChar* strName, XnDouble &dValue) const 01657 { 01658 return xnGetRealProperty(m_hNode, strName, &dValue); 01659 } 01660 01664 inline XnStatus GetStringProperty(const XnChar* strName, XnChar* csValue, XnUInt32 nBufSize) const 01665 { 01666 return xnGetStringProperty(m_hNode, strName, csValue, nBufSize); 01667 } 01668 01672 inline XnStatus GetGeneralProperty(const XnChar* strName, XnUInt32 nBufferSize, void* pBuffer) const 01673 { 01674 return xnGetGeneralProperty(m_hNode, strName, nBufferSize, pBuffer); 01675 } 01676 01680 inline XnStatus LockForChanges(XnLockHandle* phLock) 01681 { 01682 return xnLockNodeForChanges(m_hNode, phLock); 01683 } 01684 01688 inline void UnlockForChanges(XnLockHandle hLock) 01689 { 01690 xnUnlockNodeForChanges(m_hNode, hLock); 01691 } 01692 01696 inline XnStatus LockedNodeStartChanges(XnLockHandle hLock) 01697 { 01698 return xnLockedNodeStartChanges(m_hNode, hLock); 01699 } 01700 01704 inline void LockedNodeEndChanges(XnLockHandle hLock) 01705 { 01706 xnLockedNodeEndChanges(m_hNode, hLock); 01707 } 01708 01714 inline ErrorStateCapability GetErrorStateCap() 01715 { 01716 return ErrorStateCapability(m_hNode); 01717 } 01718 }; 01719 01724 class Device : public ProductionNode 01725 { 01726 public: 01732 inline Device(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {} 01733 }; 01734 01739 class MirrorCapability : public Capability 01740 { 01741 public: 01747 inline MirrorCapability(XnNodeHandle hNode) : Capability(hNode) {} 01748 01752 inline XnStatus SetMirror(XnBool bMirror) 01753 { 01754 return xnSetMirror(m_hNode, bMirror); 01755 } 01756 01760 inline XnBool IsMirrored() const 01761 { 01762 return xnIsMirrored(m_hNode); 01763 } 01764 01768 inline XnStatus RegisterToMirrorChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 01769 { 01770 return _RegisterToStateChange(xnRegisterToMirrorChange, m_hNode, handler, pCookie, hCallback); 01771 } 01772 01776 inline void UnregisterFromMirrorChange(XnCallbackHandle hCallback) 01777 { 01778 _UnregisterFromStateChange(xnUnregisterFromMirrorChange, m_hNode, hCallback); 01779 } 01780 }; 01781 01786 class AlternativeViewPointCapability : public Capability 01787 { 01788 public: 01794 inline AlternativeViewPointCapability(XnNodeHandle hNode) : Capability(hNode) {} 01795 01799 inline XnBool IsViewPointSupported(ProductionNode& otherNode) const 01800 { 01801 return xnIsViewPointSupported(m_hNode, otherNode); 01802 } 01803 01807 inline XnStatus SetViewPoint(ProductionNode& otherNode) 01808 { 01809 return xnSetViewPoint(m_hNode, otherNode); 01810 } 01811 01815 inline XnStatus ResetViewPoint() 01816 { 01817 return xnResetViewPoint(m_hNode); 01818 } 01819 01823 inline XnBool IsViewPointAs(ProductionNode& otherNode) const 01824 { 01825 return xnIsViewPointAs(m_hNode, otherNode); 01826 } 01827 01831 inline XnStatus RegisterToViewPointChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 01832 { 01833 return _RegisterToStateChange(xnRegisterToViewPointChange, m_hNode, handler, pCookie, hCallback); 01834 } 01835 01839 inline void UnregisterFromViewPointChange(XnCallbackHandle hCallback) 01840 { 01841 _UnregisterFromStateChange(xnUnregisterFromViewPointChange, m_hNode, hCallback); 01842 } 01843 }; 01844 01849 class FrameSyncCapability : public Capability 01850 { 01851 public: 01857 inline FrameSyncCapability(XnNodeHandle hNode) : Capability(hNode) {} 01858 01862 inline XnBool CanFrameSyncWith(Generator& other); 01863 01867 inline XnStatus FrameSyncWith(Generator& other); 01868 01872 inline XnStatus StopFrameSyncWith(Generator& other); 01873 01877 inline XnBool IsFrameSyncedWith(Generator& other); 01878 01882 inline XnStatus RegisterToFrameSyncChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 01883 { 01884 return _RegisterToStateChange(xnRegisterToFrameSyncChange, m_hNode, handler, pCookie, hCallback); 01885 } 01886 01890 inline void UnregisterFromFrameSyncChange(XnCallbackHandle hCallback) 01891 { 01892 _UnregisterFromStateChange(xnUnregisterFromFrameSyncChange, m_hNode, hCallback); 01893 } 01894 }; 01895 01900 class Generator : public ProductionNode 01901 { 01902 public: 01908 inline Generator(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {} 01909 01913 inline XnStatus StartGenerating() 01914 { 01915 return xnStartGenerating(m_hNode); 01916 } 01917 01921 inline XnBool IsGenerating() const 01922 { 01923 return xnIsGenerating(m_hNode); 01924 } 01925 01929 inline XnStatus StopGenerating() 01930 { 01931 return xnStopGenerating(m_hNode); 01932 } 01933 01937 inline XnStatus RegisterToGenerationRunningChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle &hCallback) 01938 { 01939 return _RegisterToStateChange(xnRegisterToGenerationRunningChange, m_hNode, handler, pCookie, hCallback); 01940 } 01941 01945 inline void UnregisterFromGenerationRunningChange(XnCallbackHandle hCallback) 01946 { 01947 _UnregisterFromStateChange(xnUnregisterFromGenerationRunningChange, m_hNode, hCallback); 01948 } 01949 01953 inline XnStatus RegisterToNewDataAvailable(StateChangedHandler handler, void* pCookie, XnCallbackHandle &hCallback) 01954 { 01955 return _RegisterToStateChange(xnRegisterToNewDataAvailable, m_hNode, handler, pCookie, hCallback); 01956 } 01957 01961 inline void UnregisterFromNewDataAvailable(XnCallbackHandle hCallback) 01962 { 01963 _UnregisterFromStateChange(xnUnregisterFromNewDataAvailable, m_hNode, hCallback); 01964 } 01965 01969 inline XnBool IsNewDataAvailable(XnUInt64* pnTimestamp = NULL) 01970 { 01971 return xnIsNewDataAvailable(m_hNode, pnTimestamp); 01972 } 01973 01977 inline XnStatus WaitAndUpdateData() 01978 { 01979 return xnWaitAndUpdateData(m_hNode); 01980 } 01981 01985 inline XnBool IsDataNew() const 01986 { 01987 return xnIsDataNew(m_hNode); 01988 } 01989 01993 inline XnUInt32 GetDataSize() const 01994 { 01995 return xnGetDataSize(m_hNode); 01996 } 01997 02001 inline XnUInt64 GetTimestamp() const 02002 { 02003 return xnGetTimestamp(m_hNode); 02004 } 02005 02009 inline XnUInt32 GetFrameID() const 02010 { 02011 return xnGetFrameID(m_hNode); 02012 } 02013 02019 inline MirrorCapability GetMirrorCap() 02020 { 02021 return MirrorCapability(m_hNode); 02022 } 02023 02029 inline AlternativeViewPointCapability GetAlternativeViewPointCap() 02030 { 02031 return AlternativeViewPointCapability(m_hNode); 02032 } 02033 02039 inline FrameSyncCapability GetFrameSyncCap() 02040 { 02041 return FrameSyncCapability(m_hNode); 02042 } 02043 }; 02044 02049 class Recorder : public ProductionNode 02050 { 02051 public: 02057 inline Recorder(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {} 02058 02062 inline XnStatus Create(Context& context, const XnChar* strFormatName); 02063 02067 inline XnStatus SetDestination(XnRecordMedium destType, const XnChar* strDest) 02068 { 02069 return xnSetRecorderDestination(m_hNode, destType, strDest); 02070 } 02071 02075 inline XnStatus AddNodeToRecording(ProductionNode& Node, XnCodecID compression = XN_CODEC_NULL) 02076 { 02077 return xnAddNodeToRecording(m_hNode, Node, compression); 02078 } 02079 02083 inline XnStatus RemoveNodeFromRecording(ProductionNode& Node) 02084 { 02085 return xnRemoveNodeFromRecording(m_hNode, Node); 02086 } 02087 02091 inline XnStatus Record() 02092 { 02093 return xnRecord(m_hNode); 02094 } 02095 }; 02096 02101 class Player : public ProductionNode 02102 { 02103 public: 02109 inline Player(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {} 02110 02114 inline XnStatus Create(Context& context, const XnChar* strFormatName); 02115 02119 inline XnStatus SetRepeat(XnBool bRepeat) 02120 { 02121 return xnSetPlayerRepeat(m_hNode, bRepeat); 02122 } 02123 02127 inline XnStatus SetSource(XnRecordMedium sourceType, const XnChar* strSource) 02128 { 02129 return xnSetPlayerSource(m_hNode, sourceType, strSource); 02130 } 02131 02135 inline XnStatus GetSource(XnRecordMedium &sourceType, XnChar* strSource, XnUInt32 nBufSize) 02136 { 02137 return xnGetPlayerSource(m_hNode, &sourceType, strSource, nBufSize); 02138 } 02139 02143 inline XnStatus ReadNext() 02144 { 02145 return xnPlayerReadNext(m_hNode); 02146 } 02147 02151 inline XnStatus SeekToTimeStamp(XnInt64 nTimeOffset, XnPlayerSeekOrigin origin) 02152 { 02153 return xnSeekPlayerToTimeStamp(m_hNode, nTimeOffset, origin); 02154 } 02155 02159 inline XnStatus SeekToFrame(const XnChar* strNodeName, XnInt32 nFrameOffset, XnPlayerSeekOrigin origin) 02160 { 02161 return xnSeekPlayerToFrame(m_hNode, strNodeName, nFrameOffset, origin); 02162 } 02163 02167 inline XnStatus TellTimestamp(XnUInt64& nTimestamp) 02168 { 02169 return xnTellPlayerTimestamp(m_hNode, &nTimestamp); 02170 } 02171 02175 inline XnStatus TellFrame(const XnChar* strNodeName, XnUInt32& nFrame) 02176 { 02177 return xnTellPlayerFrame(m_hNode, strNodeName, &nFrame); 02178 } 02179 02183 inline XnStatus GetNumFrames(const XnChar* strNodeName, XnUInt32& nFrames) 02184 { 02185 return xnGetPlayerNumFrames(m_hNode, strNodeName, &nFrames); 02186 } 02187 02191 inline const XnChar* GetSupportedFormat() 02192 { 02193 return xnGetPlayerSupportedFormat(m_hNode); 02194 } 02195 02199 inline XnStatus EnumerateNodes(NodeInfoList& list) 02200 { 02201 XnNodeInfoList* pList; 02202 XnStatus nRetVal = xnEnumeratePlayerNodes(m_hNode, &pList); 02203 XN_IS_STATUS_OK(nRetVal); 02204 02205 list.ReplaceUnderlyingObject(pList); 02206 02207 return (XN_STATUS_OK); 02208 } 02209 02213 inline XnBool IsEOF() 02214 { 02215 return xnIsPlayerAtEOF(m_hNode); 02216 } 02217 02221 inline XnStatus RegisterToEndOfFileReached(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 02222 { 02223 return _RegisterToStateChange(xnRegisterToEndOfFileReached, m_hNode, handler, pCookie, hCallback); 02224 } 02225 02229 inline void UnregisterFromEndOfFileReached(XnCallbackHandle hCallback) 02230 { 02231 _UnregisterFromStateChange(xnUnregisterFromEndOfFileReached, m_hNode, hCallback); 02232 } 02233 02237 inline XnStatus SetPlaybackSpeed(XnDouble dSpeed) 02238 { 02239 return xnSetPlaybackSpeed(m_hNode, dSpeed); 02240 } 02241 02245 inline XnDouble GetPlaybackSpeed() 02246 { 02247 return xnGetPlaybackSpeed(m_hNode); 02248 } 02249 }; 02250 02255 class CroppingCapability : public Capability 02256 { 02257 public: 02263 inline CroppingCapability(XnNodeHandle hNode) : Capability(hNode) {} 02264 02268 inline XnStatus SetCropping(const XnCropping& Cropping) 02269 { 02270 return xnSetCropping(m_hNode, &Cropping); 02271 } 02272 02276 inline XnStatus GetCropping(XnCropping& Cropping) const 02277 { 02278 return xnGetCropping(m_hNode, &Cropping); 02279 } 02280 02284 inline XnStatus RegisterToCroppingChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 02285 { 02286 return _RegisterToStateChange(xnRegisterToCroppingChange, m_hNode, handler, pCookie, hCallback); 02287 } 02288 02292 inline void UnregisterFromCroppingChange(XnCallbackHandle hCallback) 02293 { 02294 _UnregisterFromStateChange(xnUnregisterFromCroppingChange, m_hNode, hCallback); 02295 } 02296 }; 02297 02302 class MapGenerator : public Generator 02303 { 02304 public: 02310 inline MapGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {} 02311 02315 inline XnUInt32 GetSupportedMapOutputModesCount() const 02316 { 02317 return xnGetSupportedMapOutputModesCount(m_hNode); 02318 } 02319 02323 inline XnStatus GetSupportedMapOutputModes(XnMapOutputMode* aModes, XnUInt32& nCount) const 02324 { 02325 return xnGetSupportedMapOutputModes(m_hNode, aModes, &nCount); 02326 } 02327 02331 inline XnStatus SetMapOutputMode(const XnMapOutputMode& OutputMode) 02332 { 02333 return xnSetMapOutputMode(m_hNode, &OutputMode); 02334 } 02335 02339 inline XnStatus GetMapOutputMode(XnMapOutputMode &OutputMode) const 02340 { 02341 return xnGetMapOutputMode(m_hNode, &OutputMode); 02342 } 02343 02347 inline XnStatus RegisterToMapOutputModeChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 02348 { 02349 return _RegisterToStateChange(xnRegisterToMapOutputModeChange, m_hNode, handler, pCookie, hCallback); 02350 } 02351 02355 inline void UnregisterFromMapOutputModeChange(XnCallbackHandle hCallback) 02356 { 02357 _UnregisterFromStateChange(xnUnregisterFromMapOutputModeChange, m_hNode, hCallback); 02358 } 02359 02365 inline CroppingCapability GetCroppingCap() 02366 { 02367 return CroppingCapability(m_hNode); 02368 } 02369 }; 02370 02375 class UserPositionCapability : public Capability 02376 { 02377 public: 02383 inline UserPositionCapability(XnNodeHandle hNode = NULL) : Capability(hNode) {} 02384 02388 inline XnUInt32 GetSupportedUserPositionsCount() const 02389 { 02390 return xnGetSupportedUserPositionsCount(m_hNode); 02391 } 02392 02396 inline XnStatus SetUserPosition(XnUInt32 nIndex, const XnBoundingBox3D& Position) 02397 { 02398 return xnSetUserPosition(m_hNode, nIndex, &Position); 02399 } 02400 02404 inline XnStatus GetUserPosition(XnUInt32 nIndex, XnBoundingBox3D& Position) const 02405 { 02406 return xnGetUserPosition(m_hNode, nIndex, &Position); 02407 } 02408 02412 inline XnStatus RegisterToUserPositionChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 02413 { 02414 return _RegisterToStateChange(xnRegisterToUserPositionChange, m_hNode, handler, pCookie, hCallback); 02415 } 02416 02420 inline void UnregisterFromUserPositionChange(XnCallbackHandle hCallback) 02421 { 02422 _UnregisterFromStateChange(xnUnregisterFromUserPositionChange, m_hNode, hCallback); 02423 } 02424 }; 02425 02430 class DepthGenerator : public MapGenerator 02431 { 02432 public: 02438 inline DepthGenerator(XnNodeHandle hNode = NULL) : MapGenerator(hNode) {} 02439 02443 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL); 02444 02448 inline void GetMetaData(DepthMetaData& metaData) const 02449 { 02450 return xnGetDepthMetaData(m_hNode, metaData.GetUnderlying()); 02451 } 02452 02456 inline const XnDepthPixel* GetDepthMap() const 02457 { 02458 return xnGetDepthMap(m_hNode); 02459 } 02460 02464 inline XnDepthPixel GetDeviceMaxDepth() const 02465 { 02466 return xnGetDeviceMaxDepth(m_hNode); 02467 } 02468 02472 inline XnStatus GetFieldOfView(XnFieldOfView& FOV) const 02473 { 02474 return xnGetDepthFieldOfView(m_hNode, &FOV); 02475 } 02476 02480 inline XnStatus RegisterToFieldOfViewChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 02481 { 02482 return _RegisterToStateChange(xnRegisterToDepthFieldOfViewChange, m_hNode, handler, pCookie, hCallback); 02483 } 02484 02488 inline void UnregisterFromFieldOfViewChange(XnCallbackHandle hCallback) 02489 { 02490 _UnregisterFromStateChange(xnUnregisterFromDepthFieldOfViewChange, m_hNode, hCallback); 02491 } 02492 02496 inline XnStatus ConvertProjectiveToRealWorld(XnUInt32 nCount, const XnPoint3D aProjective[], XnPoint3D aRealWorld[]) const 02497 { 02498 return xnConvertProjectiveToRealWorld(m_hNode, nCount, aProjective, aRealWorld); 02499 } 02500 02504 inline XnStatus ConvertRealWorldToProjective(XnUInt32 nCount, const XnPoint3D aRealWorld[], XnPoint3D aProjective[]) const 02505 { 02506 return xnConvertRealWorldToProjective(m_hNode, nCount, aRealWorld, aProjective); 02507 } 02508 02514 inline UserPositionCapability GetUserPositionCap() 02515 { 02516 return UserPositionCapability(m_hNode); 02517 } 02518 }; 02519 02524 class MockDepthGenerator : public DepthGenerator 02525 { 02526 public: 02532 inline MockDepthGenerator(XnNodeHandle hNode = NULL) : DepthGenerator(hNode) {} 02533 02540 XnStatus Create(Context& context, const XnChar* strName = NULL); 02541 02548 XnStatus CreateBasedOn(DepthGenerator& other, const XnChar* strName = NULL); 02549 02553 inline XnStatus SetData(XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize, const XnDepthPixel* pDepthMap) 02554 { 02555 return xnMockDepthSetData(m_hNode, nFrameID, nTimestamp, nDataSize, pDepthMap); 02556 } 02557 02565 inline XnStatus SetData(DepthMetaData& depthMD, XnUInt32 nFrameID, XnUInt64 nTimestamp) 02566 { 02567 return SetData(nFrameID, nTimestamp, depthMD.DataSize(), depthMD.Data()); 02568 } 02569 02575 inline XnStatus SetData(DepthMetaData& depthMD) 02576 { 02577 return SetData(depthMD, depthMD.FrameID(), depthMD.Timestamp()); 02578 } 02579 }; 02580 02585 class ImageGenerator : public MapGenerator 02586 { 02587 public: 02593 inline ImageGenerator(XnNodeHandle hNode = NULL) : MapGenerator(hNode) {} 02594 02598 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL); 02599 02603 inline void GetMetaData(ImageMetaData& metaData) const 02604 { 02605 return xnGetImageMetaData(m_hNode, metaData.GetUnderlying()); 02606 } 02607 02611 inline const XnRGB24Pixel* GetRGB24ImageMap() const 02612 { 02613 return xnGetRGB24ImageMap(m_hNode); 02614 } 02615 02619 inline const XnYUV422DoublePixel* GetYUV422ImageMap() const 02620 { 02621 return xnGetYUV422ImageMap(m_hNode); 02622 } 02623 02627 inline const XnGrayscale8Pixel* GetGrayscale8ImageMap() const 02628 { 02629 return xnGetGrayscale8ImageMap(m_hNode); 02630 } 02631 02635 inline const XnGrayscale16Pixel* GetGrayscale16ImageMap() const 02636 { 02637 return xnGetGrayscale16ImageMap(m_hNode); 02638 } 02639 02643 inline const XnUInt8* GetImageMap() const 02644 { 02645 return xnGetImageMap(m_hNode); 02646 } 02647 02651 inline XnBool IsPixelFormatSupported(XnPixelFormat Format) const 02652 { 02653 return xnIsPixelFormatSupported(m_hNode, Format); 02654 } 02655 02659 inline XnStatus SetPixelFormat(XnPixelFormat Format) 02660 { 02661 return xnSetPixelFormat(m_hNode, Format); 02662 } 02663 02667 inline XnPixelFormat GetPixelFormat() const 02668 { 02669 return xnGetPixelFormat(m_hNode); 02670 } 02671 02675 inline XnStatus RegisterToPixelFormatChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 02676 { 02677 return _RegisterToStateChange(xnRegisterToPixelFormatChange, m_hNode, handler, pCookie, hCallback); 02678 } 02679 02683 inline void UnregisterFromPixelFormatChange(XnCallbackHandle hCallback) 02684 { 02685 _UnregisterFromStateChange(xnUnregisterFromPixelFormatChange, m_hNode, hCallback); 02686 } 02687 }; 02688 02693 class MockImageGenerator : public ImageGenerator 02694 { 02695 public: 02701 inline MockImageGenerator(XnNodeHandle hNode = NULL) : ImageGenerator(hNode) {} 02702 02709 XnStatus Create(Context& context, const XnChar* strName = NULL); 02710 02717 XnStatus CreateBasedOn(ImageGenerator& other, const XnChar* strName = NULL); 02718 02722 inline XnStatus SetData(XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize, const XnUInt8* pImageMap) 02723 { 02724 return xnMockImageSetData(m_hNode, nFrameID, nTimestamp, nDataSize, pImageMap); 02725 } 02726 02734 inline XnStatus SetData(ImageMetaData& imageMD, XnUInt32 nFrameID, XnUInt64 nTimestamp) 02735 { 02736 return SetData(nFrameID, nTimestamp, imageMD.DataSize(), imageMD.Data()); 02737 } 02738 02744 inline XnStatus SetData(ImageMetaData& imageMD) 02745 { 02746 return SetData(imageMD, imageMD.FrameID(), imageMD.Timestamp()); 02747 } 02748 }; 02749 02754 class IRGenerator : public MapGenerator 02755 { 02756 public: 02762 inline IRGenerator(XnNodeHandle hNode = NULL) : MapGenerator(hNode) {} 02763 02767 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL); 02768 02772 inline void GetMetaData(IRMetaData& metaData) const 02773 { 02774 xnGetIRMetaData(m_hNode, metaData.GetUnderlying()); 02775 } 02776 02780 inline const XnIRPixel* GetIRMap() const 02781 { 02782 return xnGetIRMap(m_hNode); 02783 } 02784 }; 02785 02790 class MockIRGenerator : public IRGenerator 02791 { 02792 public: 02798 inline MockIRGenerator(XnNodeHandle hNode = NULL) : IRGenerator(hNode) {} 02799 02806 XnStatus Create(Context& context, const XnChar* strName = NULL); 02813 XnStatus CreateBasedOn(IRGenerator& other, const XnChar* strName = NULL); 02814 02818 inline XnStatus SetData(XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize, const XnIRPixel* pIRMap) 02819 { 02820 return xnMockIRSetData(m_hNode, nFrameID, nTimestamp, nDataSize, pIRMap); 02821 } 02822 02830 inline XnStatus SetData(IRMetaData& irMD, XnUInt32 nFrameID, XnUInt64 nTimestamp) 02831 { 02832 return SetData(nFrameID, nTimestamp, irMD.DataSize(), irMD.Data()); 02833 } 02834 02840 inline XnStatus SetData(IRMetaData& irMD) 02841 { 02842 return SetData(irMD, irMD.FrameID(), irMD.Timestamp()); 02843 } 02844 }; 02845 02850 class GestureGenerator : public Generator 02851 { 02852 public: 02858 inline GestureGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {} 02859 02863 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL); 02864 02868 inline XnStatus AddGesture(const XnChar* strGesture, XnBoundingBox3D* pArea) 02869 { 02870 return xnAddGesture(m_hNode, strGesture, pArea); 02871 } 02872 02876 inline XnStatus RemoveGesture(const XnChar* strGesture) 02877 { 02878 return xnRemoveGesture(m_hNode, strGesture); 02879 } 02880 02884 inline XnStatus GetActiveGestures(XnChar*& astrGestures, XnUInt16& nGestures) const 02885 { 02886 return xnGetActiveGestures(m_hNode, &astrGestures, &nGestures); 02887 } 02888 02892 inline XnStatus GetAllActiveGestures(XnChar** astrGestures, XnUInt32 nNameLength, XnUInt16& nGestures) const 02893 { 02894 return xnGetAllActiveGestures(m_hNode, astrGestures, nNameLength, &nGestures); 02895 } 02896 02900 inline XnStatus EnumerateGestures(XnChar*& astrGestures, XnUInt16& nGestures) 02901 { 02902 return xnEnumerateGestures(m_hNode, &astrGestures, &nGestures); 02903 } 02907 inline XnStatus EnumerateAllGestures(XnChar** astrGestures, XnUInt32 nNameLength, XnUInt16& nGestures) 02908 { 02909 return xnEnumerateAllGestures(m_hNode, astrGestures, nNameLength, &nGestures); 02910 } 02911 02915 inline XnBool IsGestureAvailable(const XnChar* strGesture) 02916 { 02917 return xnIsGestureAvailable(m_hNode, strGesture); 02918 } 02919 02923 inline XnBool IsGestureProgressSupported(const XnChar* strGesture) 02924 { 02925 return xnIsGestureProgressSupported(m_hNode, strGesture); 02926 } 02927 02937 typedef void (XN_CALLBACK_TYPE* GestureRecognized)(GestureGenerator& generator, const XnChar* strGesture, const XnPoint3D* pIDPosition, const XnPoint3D* pEndPosition, void* pCookie); 02947 typedef void (XN_CALLBACK_TYPE* GestureProgress)(GestureGenerator& generator, const XnChar* strGesture, const XnPoint3D* pPosition, XnFloat fProgress, void* pCookie); 02948 02952 XnStatus RegisterGestureCallbacks(GestureRecognized RecognizedCB, GestureProgress ProgressCB, void* pCookie, XnCallbackHandle& hCallback) 02953 { 02954 XnStatus nRetVal = XN_STATUS_OK; 02955 02956 GestureCookie* pGestureCookie; 02957 XN_VALIDATE_ALLOC(pGestureCookie, GestureCookie); 02958 pGestureCookie->recognizedHandler = RecognizedCB; 02959 pGestureCookie->progressHandler = ProgressCB; 02960 pGestureCookie->pUserCookie = pCookie; 02961 02962 nRetVal = xnRegisterGestureCallbacks(m_hNode, GestureRecognizedCallback, GestureProgressCallback, pGestureCookie, &pGestureCookie->hCallback); 02963 if (nRetVal != XN_STATUS_OK) 02964 { 02965 xnOSFree(pGestureCookie); 02966 return (nRetVal); 02967 } 02968 02969 hCallback = pGestureCookie; 02970 02971 return (XN_STATUS_OK); 02972 } 02973 02977 inline void UnregisterGestureCallbacks(XnCallbackHandle hCallback) 02978 { 02979 GestureCookie* pGestureCookie = (GestureCookie*)hCallback; 02980 xnUnregisterGestureCallbacks(m_hNode, pGestureCookie->hCallback); 02981 xnOSFree(pGestureCookie); 02982 } 02983 02987 inline XnStatus RegisterToGestureChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 02988 { 02989 return _RegisterToStateChange(xnRegisterToGestureChange, m_hNode, handler, pCookie, hCallback); 02990 } 02991 02995 inline void UnregisterFromGestureChange(XnCallbackHandle hCallback) 02996 { 02997 _UnregisterFromStateChange(xnUnregisterFromGestureChange, m_hNode, hCallback); 02998 } 02999 03000 private: 03001 typedef struct GestureCookie 03002 { 03003 GestureRecognized recognizedHandler; 03004 GestureProgress progressHandler; 03005 void* pUserCookie; 03006 XnCallbackHandle hCallback; 03007 } GestureCookie; 03008 03009 static void XN_CALLBACK_TYPE GestureRecognizedCallback(XnNodeHandle hNode, const XnChar* strGesture, const XnPoint3D* pIDPosition, const XnPoint3D* pEndPosition, void* pCookie) 03010 { 03011 GestureCookie* pGestureCookie = (GestureCookie*)pCookie; 03012 GestureGenerator gen(hNode); 03013 if (pGestureCookie->recognizedHandler != NULL) 03014 { 03015 pGestureCookie->recognizedHandler(gen, strGesture, pIDPosition, pEndPosition, pGestureCookie->pUserCookie); 03016 } 03017 } 03018 03019 static void XN_CALLBACK_TYPE GestureProgressCallback(XnNodeHandle hNode, const XnChar* strGesture, const XnPoint3D* pPosition, XnFloat fProgress, void* pCookie) 03020 { 03021 GestureCookie* pGestureCookie = (GestureCookie*)pCookie; 03022 GestureGenerator gen(hNode); 03023 if (pGestureCookie->progressHandler != NULL) 03024 { 03025 pGestureCookie->progressHandler(gen, strGesture, pPosition, fProgress, pGestureCookie->pUserCookie); 03026 } 03027 } 03028 }; 03029 03034 class SceneAnalyzer : public MapGenerator 03035 { 03036 public: 03042 inline SceneAnalyzer(XnNodeHandle hNode = NULL) : MapGenerator(hNode) {} 03043 03047 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL); 03048 03052 inline void GetMetaData(SceneMetaData& metaData) const 03053 { 03054 xnGetSceneMetaData(m_hNode, metaData.GetUnderlying()); 03055 } 03056 03060 inline const XnLabel* GetLabelMap() const 03061 { 03062 return xnGetLabelMap(m_hNode); 03063 } 03064 03068 inline XnStatus GetFloor(XnPlane3D& Plane) const 03069 { 03070 return xnGetFloor(m_hNode, &Plane); 03071 } 03072 }; 03073 03078 class HandsGenerator : public Generator 03079 { 03080 public: 03086 inline HandsGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {} 03087 03091 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL); 03092 03102 typedef void (XN_CALLBACK_TYPE* HandCreate)(HandsGenerator& generator, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, void* pCookie); 03112 typedef void (XN_CALLBACK_TYPE* HandUpdate)(HandsGenerator& generator, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, void* pCookie); 03121 typedef void (XN_CALLBACK_TYPE* HandDestroy)(HandsGenerator& generator, XnUserID user, XnFloat fTime, void* pCookie); 03122 03126 inline XnStatus RegisterHandCallbacks(HandCreate CreateCB, HandUpdate UpdateCB, HandDestroy DestroyCB, void* pCookie, XnCallbackHandle& hCallback) 03127 { 03128 XnStatus nRetVal = XN_STATUS_OK; 03129 03130 HandCookie* pHandCookie; 03131 XN_VALIDATE_ALLOC(pHandCookie, HandCookie); 03132 pHandCookie->createHandler = CreateCB; 03133 pHandCookie->updateHandler = UpdateCB; 03134 pHandCookie->destroyHandler = DestroyCB; 03135 pHandCookie->pUserCookie = pCookie; 03136 03137 nRetVal = xnRegisterHandCallbacks(m_hNode, HandCreateCB, HandUpdateCB, HandDestroyCB, pHandCookie, &pHandCookie->hCallback); 03138 if (nRetVal != XN_STATUS_OK) 03139 { 03140 xnOSFree(pHandCookie); 03141 return (nRetVal); 03142 } 03143 03144 hCallback = pHandCookie; 03145 03146 return (XN_STATUS_OK); 03147 } 03148 03152 inline void UnregisterHandCallbacks(XnCallbackHandle hCallback) 03153 { 03154 HandCookie* pHandCookie = (HandCookie*)hCallback; 03155 xnUnregisterHandCallbacks(m_hNode, pHandCookie->hCallback); 03156 xnOSFree(pHandCookie); 03157 } 03158 03162 inline XnStatus StopTracking(XnUserID user) 03163 { 03164 return xnStopTracking(m_hNode, user); 03165 } 03166 03170 inline XnStatus StopTrackingAll() 03171 { 03172 return xnStopTrackingAll(m_hNode); 03173 } 03174 03178 inline XnStatus StartTracking(const XnPoint3D& ptPosition) 03179 { 03180 return xnStartTracking(m_hNode, &ptPosition); 03181 } 03182 03186 inline XnStatus SetSmoothing(XnFloat fSmoothingFactor) 03187 { 03188 return xnSetTrackingSmoothing(m_hNode, fSmoothingFactor); 03189 } 03190 03191 private: 03192 typedef struct HandCookie 03193 { 03194 HandCreate createHandler; 03195 HandUpdate updateHandler; 03196 HandDestroy destroyHandler; 03197 void* pUserCookie; 03198 XnCallbackHandle hCallback; 03199 } HandCookie; 03200 03201 static void XN_CALLBACK_TYPE HandCreateCB(XnNodeHandle hNode, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, void* pCookie) 03202 { 03203 HandCookie* pHandCookie = (HandCookie*)pCookie; 03204 HandsGenerator gen(hNode); 03205 if (pHandCookie->createHandler != NULL) 03206 { 03207 pHandCookie->createHandler(gen, user, pPosition, fTime, pHandCookie->pUserCookie); 03208 } 03209 } 03210 static void XN_CALLBACK_TYPE HandUpdateCB(XnNodeHandle hNode, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, void* pCookie) 03211 { 03212 HandCookie* pHandCookie = (HandCookie*)pCookie; 03213 HandsGenerator gen(hNode); 03214 if (pHandCookie->updateHandler != NULL) 03215 { 03216 pHandCookie->updateHandler(gen, user, pPosition, fTime, pHandCookie->pUserCookie); 03217 } 03218 } 03219 static void XN_CALLBACK_TYPE HandDestroyCB(XnNodeHandle hNode, XnUserID user, XnFloat fTime, void* pCookie) 03220 { 03221 HandCookie* pHandCookie = (HandCookie*)pCookie; 03222 HandsGenerator gen(hNode); 03223 if (pHandCookie->destroyHandler != NULL) 03224 { 03225 pHandCookie->destroyHandler(gen, user, fTime, pHandCookie->pUserCookie); 03226 } 03227 } 03228 }; 03229 03234 class SkeletonCapability : public Capability 03235 { 03236 public: 03242 inline SkeletonCapability(XnNodeHandle hNode) : Capability(hNode) {} 03243 03247 inline XnBool IsJointAvailable(XnSkeletonJoint eJoint) const 03248 { 03249 return xnIsJointAvailable(m_hNode, eJoint); 03250 } 03251 03255 inline XnBool IsProfileAvailable(XnSkeletonProfile eProfile) const 03256 { 03257 return xnIsProfileAvailable(m_hNode, eProfile); 03258 } 03259 03263 inline XnStatus SetSkeletonProfile(XnSkeletonProfile eProfile) 03264 { 03265 return xnSetSkeletonProfile(m_hNode, eProfile); 03266 } 03267 03271 inline XnStatus SetJointActive(XnSkeletonJoint eJoint, XnBool bState) 03272 { 03273 return xnSetJointActive(m_hNode, eJoint, bState); 03274 } 03275 03279 inline XnBool IsJointActive(XnSkeletonJoint eJoint, XnBool bState) 03280 { 03281 return xnIsJointActive(m_hNode, eJoint); 03282 } 03283 03287 inline XnStatus RegisterToJointConfigurationChange(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 03288 { 03289 return _RegisterToStateChange(xnRegisterToJointConfigurationChange, m_hNode, handler, pCookie, hCallback); 03290 } 03291 03295 inline void UnregisterFromJointConfigurationChange(XnCallbackHandle hCallback) 03296 { 03297 _UnregisterFromStateChange(xnUnregisterFromJointConfigurationChange, m_hNode, hCallback); 03298 } 03299 03303 inline XnStatus EnumerateActiveJoints(XnSkeletonJoint* pJoints, XnUInt16& nJoints) 03304 { 03305 return xnEnumerateActiveJoints(m_hNode, pJoints, &nJoints); 03306 } 03307 03311 inline XnStatus GetSkeletonJoint(XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointTransformation& Joint) const 03312 { 03313 return xnGetSkeletonJoint(m_hNode, user, eJoint, &Joint); 03314 } 03315 03319 inline XnStatus GetSkeletonJointPosition(XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointPosition& Joint) const 03320 { 03321 return xnGetSkeletonJointPosition(m_hNode, user, eJoint, &Joint); 03322 } 03323 03327 inline XnStatus GetSkeletonJointOrientation(XnUserID user, XnSkeletonJoint eJoint, XnSkeletonJointOrientation& Joint) const 03328 { 03329 return xnGetSkeletonJointOrientation(m_hNode, user, eJoint, &Joint); 03330 } 03331 03335 inline XnBool IsTracking(XnUserID user) 03336 { 03337 return xnIsSkeletonTracking(m_hNode, user); 03338 } 03339 03343 inline XnBool IsCalibrated(XnUserID user) 03344 { 03345 return xnIsSkeletonCalibrated(m_hNode, user); 03346 } 03347 03351 inline XnBool IsCalibrating(XnUserID user) 03352 { 03353 return xnIsSkeletonCalibrating(m_hNode, user); 03354 } 03355 03359 inline XnStatus RequestCalibration(XnUserID user, XnBool bForce) 03360 { 03361 return xnRequestSkeletonCalibration(m_hNode, user, bForce); 03362 } 03363 03367 inline XnStatus AbortCalibration(XnUserID user) 03368 { 03369 return xnAbortSkeletonCalibration(m_hNode, user); 03370 } 03371 03375 inline XnStatus SaveCalibrationData(XnUserID user, XnUInt32 nSlot) 03376 { 03377 return xnSaveSkeletonCalibrationData(m_hNode, user, nSlot); 03378 } 03379 03383 inline XnStatus LoadCalibrationData(XnUserID user, XnUInt32 nSlot) 03384 { 03385 return xnLoadSkeletonCalibrationData(m_hNode, user, nSlot); 03386 } 03387 03391 inline XnStatus ClearCalibrationData(XnUInt32 nSlot) 03392 { 03393 return xnClearSkeletonCalibrationData(m_hNode, nSlot); 03394 } 03395 03399 inline XnBool IsCalibrationData(XnUInt32 nSlot) 03400 { 03401 return xnIsSkeletonCalibrationData(m_hNode, nSlot); 03402 } 03403 03407 inline XnStatus StartTracking(XnUserID user) 03408 { 03409 return xnStartSkeletonTracking(m_hNode, user); 03410 } 03411 03415 inline XnStatus StopTracking(XnUserID user) 03416 { 03417 return xnStopSkeletonTracking(m_hNode, user); 03418 } 03419 03423 inline XnStatus Reset(XnUserID user) 03424 { 03425 return xnResetSkeleton(m_hNode, user); 03426 } 03427 03431 inline XnBool NeedPoseForCalibration() 03432 { 03433 return xnNeedPoseForSkeletonCalibration(m_hNode); 03434 } 03435 03439 inline XnStatus GetCalibrationPose(XnChar* strPose) 03440 { 03441 return xnGetSkeletonCalibrationPose(m_hNode, strPose); 03442 } 03443 03447 inline XnStatus SetSmoothing(XnFloat fSmoothingFactor) 03448 { 03449 return xnSetSkeletonSmoothing(m_hNode, fSmoothingFactor); 03450 } 03451 03459 typedef void (XN_CALLBACK_TYPE* CalibrationStart)(SkeletonCapability& skeleton, XnUserID user, void* pCookie); 03468 typedef void (XN_CALLBACK_TYPE* CalibrationEnd)(SkeletonCapability& skeleton, XnUserID user, XnBool bSuccess, void* pCookie); 03469 03473 inline XnStatus RegisterCalibrationCallbacks(CalibrationStart CalibrationStartCB, CalibrationEnd CalibrationEndCB, void* pCookie, XnCallbackHandle& hCallback) 03474 { 03475 XnStatus nRetVal = XN_STATUS_OK; 03476 03477 SkeletonCookie* pSkeletonCookie; 03478 XN_VALIDATE_ALLOC(pSkeletonCookie, SkeletonCookie); 03479 pSkeletonCookie->startHandler = CalibrationStartCB; 03480 pSkeletonCookie->endHandler = CalibrationEndCB; 03481 pSkeletonCookie->pUserCookie = pCookie; 03482 03483 nRetVal = xnRegisterCalibrationCallbacks(m_hNode, CalibrationStartCallback, CalibrationEndCallback, pSkeletonCookie, &pSkeletonCookie->hCallback); 03484 if (nRetVal != XN_STATUS_OK) 03485 { 03486 xnOSFree(pSkeletonCookie); 03487 return (nRetVal); 03488 } 03489 03490 hCallback = pSkeletonCookie; 03491 03492 return (XN_STATUS_OK); 03493 } 03494 03498 inline void UnregisterCalibrationCallbacks(XnCallbackHandle hCallback) 03499 { 03500 SkeletonCookie* pSkeletonCookie = (SkeletonCookie*)hCallback; 03501 xnUnregisterCalibrationCallbacks(m_hNode, pSkeletonCookie->hCallback); 03502 xnOSFree(pSkeletonCookie); 03503 } 03504 03505 private: 03506 typedef struct SkeletonCookie 03507 { 03508 CalibrationStart startHandler; 03509 CalibrationEnd endHandler; 03510 void* pUserCookie; 03511 XnCallbackHandle hCallback; 03512 } SkeletonCookie; 03513 03514 static void XN_CALLBACK_TYPE CalibrationStartCallback(XnNodeHandle hNode, XnUserID user, void* pCookie) 03515 { 03516 SkeletonCookie* pSkeletonCookie = (SkeletonCookie*)pCookie; 03517 SkeletonCapability cap(hNode); 03518 if (pSkeletonCookie->startHandler != NULL) 03519 { 03520 pSkeletonCookie->startHandler(cap, user, pSkeletonCookie->pUserCookie); 03521 } 03522 } 03523 03524 static void XN_CALLBACK_TYPE CalibrationEndCallback(XnNodeHandle hNode, XnUserID user, XnBool bSuccess, void* pCookie) 03525 { 03526 SkeletonCookie* pSkeletonCookie = (SkeletonCookie*)pCookie; 03527 SkeletonCapability cap(hNode); 03528 if (pSkeletonCookie->endHandler != NULL) 03529 { 03530 pSkeletonCookie->endHandler(cap, user, bSuccess, pSkeletonCookie->pUserCookie); 03531 } 03532 } 03533 }; 03534 03539 class PoseDetectionCapability : public Capability 03540 { 03541 public: 03547 inline PoseDetectionCapability(XnNodeHandle hNode) : Capability(hNode) {} 03548 03557 typedef void (XN_CALLBACK_TYPE* PoseDetection)(PoseDetectionCapability& pose, const XnChar* strPose, XnUserID user, void* pCookie); 03558 03562 inline XnUInt32 GetNumberOfPoses() 03563 { 03564 return xnGetNumberOfPoses(m_hNode); 03565 } 03566 03570 inline XnStatus GetAvailablePoses(XnChar** pstrPoses, XnUInt32& nPoses) 03571 { 03572 return xnGetAvailablePoses(m_hNode, pstrPoses, &nPoses); 03573 } 03577 inline XnStatus GetAllAvailablePoses(XnChar** pstrPoses, XnUInt32 nNameLength, XnUInt32& nPoses) 03578 { 03579 return xnGetAllAvailablePoses(m_hNode, pstrPoses, nNameLength, &nPoses); 03580 } 03581 03585 inline XnStatus StartPoseDetection(const XnChar* strPose, XnUserID user) 03586 { 03587 return xnStartPoseDetection(m_hNode, strPose, user); 03588 } 03589 03593 inline XnStatus StopPoseDetection(XnUserID user) 03594 { 03595 return xnStopPoseDetection(m_hNode, user); 03596 } 03597 03601 inline XnStatus RegisterToPoseCallbacks(PoseDetection PoseStartCB, PoseDetection PoseEndCB, void* pCookie, XnCallbackHandle& hCallback) 03602 { 03603 XnStatus nRetVal = XN_STATUS_OK; 03604 03605 PoseCookie* pPoseCookie; 03606 XN_VALIDATE_ALLOC(pPoseCookie, PoseCookie); 03607 pPoseCookie->startHandler = PoseStartCB; 03608 pPoseCookie->endHandler = PoseEndCB; 03609 pPoseCookie->pPoseCookie = pCookie; 03610 03611 nRetVal = xnRegisterToPoseCallbacks(m_hNode, PoseDetectionStartCallback, PoseDetectionStartEndCallback, pPoseCookie, &pPoseCookie->hCallback); 03612 if (nRetVal != XN_STATUS_OK) 03613 { 03614 xnOSFree(pPoseCookie); 03615 return (nRetVal); 03616 } 03617 03618 hCallback = pPoseCookie; 03619 03620 return (XN_STATUS_OK); 03621 } 03622 03626 inline void UnregisterFromPoseCallbacks(XnCallbackHandle hCallback) 03627 { 03628 PoseCookie* pPoseCookie = (PoseCookie*)hCallback; 03629 xnUnregisterCalibrationCallbacks(m_hNode, pPoseCookie->hCallback); 03630 xnOSFree(pPoseCookie); 03631 } 03632 private: 03633 typedef struct PoseCookie 03634 { 03635 PoseDetection startHandler; 03636 PoseDetection endHandler; 03637 void* pPoseCookie; 03638 XnCallbackHandle hCallback; 03639 } PoseCookie; 03640 03641 static void XN_CALLBACK_TYPE PoseDetectionStartCallback(XnNodeHandle hNode, const XnChar* strPose, XnUserID user, void* pCookie) 03642 { 03643 PoseCookie* pPoseCookie = (PoseCookie*)pCookie; 03644 PoseDetectionCapability cap(hNode); 03645 if (pPoseCookie->startHandler != NULL) 03646 { 03647 pPoseCookie->startHandler(cap, strPose, user, pPoseCookie->pPoseCookie); 03648 } 03649 } 03650 03651 static void XN_CALLBACK_TYPE PoseDetectionStartEndCallback(XnNodeHandle hNode, const XnChar* strPose, XnUserID user, void* pCookie) 03652 { 03653 PoseCookie* pPoseCookie = (PoseCookie*)pCookie; 03654 PoseDetectionCapability cap(hNode); 03655 if (pPoseCookie->endHandler != NULL) 03656 { 03657 pPoseCookie->endHandler(cap, strPose, user, pPoseCookie->pPoseCookie); 03658 } 03659 } 03660 }; 03661 03666 class UserGenerator : public Generator 03667 { 03668 public: 03674 inline UserGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {} 03675 03679 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL); 03680 03681 typedef void (XN_CALLBACK_TYPE* UserHandler)(UserGenerator& generator, XnUserID user, void* pCookie); 03682 03686 inline XnUInt16 GetNumberOfUsers() const 03687 { 03688 return xnGetNumberOfUsers(m_hNode); 03689 } 03690 03694 inline XnStatus GetUsers(XnUserID aUsers[], XnUInt16& nUsers) const 03695 { 03696 return xnGetUsers(m_hNode, aUsers, &nUsers); 03697 } 03698 03702 inline XnStatus GetCoM(XnUserID user, XnPoint3D& com) const 03703 { 03704 return xnGetUserCoM(m_hNode, user, &com); 03705 } 03706 03710 inline XnStatus GetUserPixels(XnUserID user, SceneMetaData& smd) 03711 { 03712 return xnGetUserPixels(m_hNode, user, smd.GetUnderlying()); 03713 } 03714 03718 inline XnStatus RegisterUserCallbacks(UserHandler NewUserCB, UserHandler LostUserCB, void* pCookie, XnCallbackHandle& hCallback) 03719 { 03720 XnStatus nRetVal = XN_STATUS_OK; 03721 03722 UserCookie* pUserCookie; 03723 XN_VALIDATE_ALLOC(pUserCookie, UserCookie); 03724 pUserCookie->newHandler = NewUserCB; 03725 pUserCookie->lostHandler = LostUserCB; 03726 pUserCookie->pUserCookie = pCookie; 03727 03728 nRetVal = xnRegisterUserCallbacks(m_hNode, NewUserCallback, LostUserCallback, pUserCookie, &pUserCookie->hCallback); 03729 if (nRetVal != XN_STATUS_OK) 03730 { 03731 xnOSFree(pUserCookie); 03732 return (nRetVal); 03733 } 03734 03735 hCallback = pUserCookie; 03736 03737 return (XN_STATUS_OK); 03738 } 03739 03743 inline void UnregisterUserCallbacks(XnCallbackHandle hCallback) 03744 { 03745 UserCookie* pUserCookie = (UserCookie*)hCallback; 03746 xnUnregisterUserCallbacks(m_hNode, pUserCookie->hCallback); 03747 xnOSFree(pUserCookie); 03748 } 03749 03755 inline SkeletonCapability GetSkeletonCap() 03756 { 03757 return SkeletonCapability(m_hNode); 03758 } 03759 03765 inline PoseDetectionCapability GetPoseDetectionCap() 03766 { 03767 return PoseDetectionCapability(m_hNode); 03768 } 03769 03770 private: 03771 typedef struct UserCookie 03772 { 03773 UserHandler newHandler; 03774 UserHandler lostHandler; 03775 void* pUserCookie; 03776 XnCallbackHandle hCallback; 03777 } UserCookie; 03778 03779 static void XN_CALLBACK_TYPE NewUserCallback(XnNodeHandle hNode, XnUserID user, void* pCookie) 03780 { 03781 UserCookie* pUserCookie = (UserCookie*)pCookie; 03782 UserGenerator gen(hNode); 03783 if (pUserCookie->newHandler != NULL) 03784 { 03785 pUserCookie->newHandler(gen, user, pUserCookie->pUserCookie); 03786 } 03787 } 03788 03789 static void XN_CALLBACK_TYPE LostUserCallback(XnNodeHandle hNode, XnUserID user, void* pCookie) 03790 { 03791 UserCookie* pUserCookie = (UserCookie*)pCookie; 03792 UserGenerator gen(hNode); 03793 if (pUserCookie->lostHandler != NULL) 03794 { 03795 pUserCookie->lostHandler(gen, user, pUserCookie->pUserCookie); 03796 } 03797 } 03798 }; 03799 03804 class AudioGenerator : public Generator 03805 { 03806 public: 03812 inline AudioGenerator(XnNodeHandle hNode = NULL) : Generator(hNode) {} 03813 03817 inline XnStatus Create(Context& context, Query* pQuery = NULL, EnumerationErrors* pErrors = NULL); 03818 03822 inline void GetMetaData(AudioMetaData& metaData) const 03823 { 03824 xnGetAudioMetaData(m_hNode, metaData.GetUnderlying()); 03825 } 03826 03830 inline const XnUChar* GetAudioBuffer() const 03831 { 03832 return xnGetAudioBuffer(m_hNode); 03833 } 03834 03838 inline XnUInt32 GetSupportedWaveOutputModesCount() const 03839 { 03840 return xnGetSupportedWaveOutputModesCount(m_hNode); 03841 } 03842 03846 inline XnStatus GetSupportedWaveOutputModes(XnWaveOutputMode* aSupportedModes, XnUInt32& nCount) const 03847 { 03848 return xnGetSupportedWaveOutputModes(m_hNode, aSupportedModes, &nCount); 03849 } 03850 03854 inline XnStatus SetWaveOutputMode(const XnWaveOutputMode& OutputMode) 03855 { 03856 return xnSetWaveOutputMode(m_hNode, &OutputMode); 03857 } 03858 03862 inline XnStatus GetWaveOutputMode(XnWaveOutputMode& OutputMode) const 03863 { 03864 return xnGetWaveOutputMode(m_hNode, &OutputMode); 03865 } 03866 03870 inline XnStatus RegisterToWaveOutputModeChanges(StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 03871 { 03872 return _RegisterToStateChange(xnRegisterToWaveOutputModeChanges, m_hNode, handler, pCookie, hCallback); 03873 } 03874 03878 inline void UnregisterFromWaveOutputModeChanges(XnCallbackHandle hCallback) 03879 { 03880 _UnregisterFromStateChange(xnUnregisterFromWaveOutputModeChanges, m_hNode, hCallback); 03881 } 03882 }; 03883 03888 class MockAudioGenerator : public AudioGenerator 03889 { 03890 public: 03896 inline MockAudioGenerator(XnNodeHandle hNode = NULL) : AudioGenerator(hNode) {} 03897 03904 XnStatus Create(Context& context, const XnChar* strName = NULL); 03905 03912 XnStatus CreateBasedOn(AudioGenerator& other, const XnChar* strName = NULL); 03913 03917 inline XnStatus SetData(XnUInt32 nFrameID, XnUInt64 nTimestamp, XnUInt32 nDataSize, const XnUInt8* pAudioBuffer) 03918 { 03919 return xnMockAudioSetData(m_hNode, nFrameID, nTimestamp, nDataSize, pAudioBuffer); 03920 } 03921 03929 inline XnStatus SetData(AudioMetaData& audioMD, XnUInt32 nFrameID, XnUInt64 nTimestamp) 03930 { 03931 return SetData(nFrameID, nTimestamp, audioMD.DataSize(), audioMD.Data()); 03932 } 03933 03939 inline XnStatus SetData(AudioMetaData& audioMD) 03940 { 03941 return SetData(audioMD, audioMD.FrameID(), audioMD.Timestamp()); 03942 } 03943 }; 03944 03945 //--------------------------------------------------------------------------- 03946 // Codec 03947 //--------------------------------------------------------------------------- 03952 class Codec : public ProductionNode 03953 { 03954 public: 03960 inline Codec(XnNodeHandle hNode = NULL) : ProductionNode(hNode) {} 03961 03965 inline XnStatus Create(Context& context, XnCodecID codecID, ProductionNode& initializerNode); 03966 03970 inline XnCodecID GetCodecID() const 03971 { 03972 return xnGetCodecID(m_hNode); 03973 } 03974 03978 inline XnStatus EncodeData(const void* pSrc, XnUInt32 nSrcSize, void* pDst, XnUInt32 nDstSize, XnUInt* pnBytesWritten) const 03979 { 03980 return xnEncodeData(m_hNode, pSrc, nSrcSize, pDst, nDstSize, pnBytesWritten); 03981 } 03982 03986 inline XnStatus DecodeData(const void* pSrc, XnUInt32 nSrcSize, void* pDst, XnUInt32 nDstSize, XnUInt* pnBytesWritten) const 03987 { 03988 return xnDecodeData(m_hNode, pSrc, nSrcSize, pDst, nDstSize, pnBytesWritten); 03989 } 03990 }; 03991 03992 //--------------------------------------------------------------------------- 03993 // EnumerationErrors 03994 //--------------------------------------------------------------------------- 03999 class EnumerationErrors 04000 { 04001 public: 04003 inline EnumerationErrors() : m_bAllocated(TRUE), m_pErrors(NULL) { xnEnumerationErrorsAllocate(&m_pErrors); } 04004 04011 inline EnumerationErrors(XnEnumerationErrors* pErrors, XnBool bOwn = FALSE) : m_bAllocated(bOwn), m_pErrors(pErrors) {} 04012 04014 ~EnumerationErrors() { Free(); } 04015 04017 class Iterator 04018 { 04019 public: 04020 friend class EnumerationErrors; 04021 04027 XnBool operator==(const Iterator& other) const 04028 { 04029 return m_it == other.m_it; 04030 } 04031 04037 XnBool operator!=(const Iterator& other) const 04038 { 04039 return m_it != other.m_it; 04040 } 04041 04046 inline Iterator& operator++() 04047 { 04048 m_it = xnEnumerationErrorsGetNext(m_it); 04049 return *this; 04050 } 04051 04056 inline Iterator operator++(int) 04057 { 04058 return Iterator(xnEnumerationErrorsGetNext(m_it)); 04059 } 04060 04062 inline const XnProductionNodeDescription& Description() { return *xnEnumerationErrorsGetCurrentDescription(m_it); } 04064 inline XnStatus Error() { return xnEnumerationErrorsGetCurrentError(m_it); } 04065 04066 private: 04067 inline Iterator(XnEnumerationErrorsIterator it) : m_it(it) {} 04068 04069 XnEnumerationErrorsIterator m_it; 04070 }; 04071 04073 inline Iterator Begin() const { return Iterator(xnEnumerationErrorsGetFirst(m_pErrors)); } 04075 inline Iterator End() const { return Iterator(NULL); } 04076 04080 inline XnStatus ToString(XnChar* csBuffer, XnUInt32 nSize) 04081 { 04082 return xnEnumerationErrorsToString(m_pErrors, csBuffer, nSize); 04083 } 04084 04088 inline void Free() 04089 { 04090 if (m_bAllocated) 04091 { 04092 xnEnumerationErrorsFree(m_pErrors); 04093 m_pErrors = NULL; 04094 m_bAllocated = FALSE; 04095 } 04096 } 04097 04099 inline XnEnumerationErrors* GetUnderlying() { return m_pErrors; } 04100 04101 private: 04102 XnEnumerationErrors* m_pErrors; 04103 XnBool m_bAllocated; 04104 }; 04105 04106 //--------------------------------------------------------------------------- 04107 // Context 04108 //--------------------------------------------------------------------------- 04109 04114 class Context 04115 { 04116 public: 04118 inline Context() : m_pContext(NULL), m_bAllocated(FALSE) {} 04124 inline Context(XnContext* pContext) : m_pContext(pContext), m_bAllocated(FALSE) {} 04131 inline Context(const Context& other) : m_pContext(other.m_pContext), m_bAllocated(FALSE) {} 04132 04134 ~Context() 04135 { 04136 FreeImpl(); 04137 } 04138 04140 inline XnContext* GetUnderlyingObject() const { return m_pContext; } 04141 04145 inline XnStatus Init() 04146 { 04147 XnStatus nRetVal = xnInit(&m_pContext); 04148 XN_IS_STATUS_OK(nRetVal); 04149 m_bAllocated = TRUE; 04150 return (XN_STATUS_OK); 04151 } 04152 04156 inline XnStatus RunXmlScript(const XnChar* strScript, EnumerationErrors* pErrors = NULL) 04157 { 04158 return xnContextRunXmlScript(m_pContext, strScript, pErrors == NULL ? NULL : pErrors->GetUnderlying()); 04159 } 04160 04164 inline XnStatus RunXmlScriptFromFile(const XnChar* strFileName, EnumerationErrors* pErrors = NULL) 04165 { 04166 return xnContextRunXmlScriptFromFile(m_pContext, strFileName, pErrors == NULL ? NULL : pErrors->GetUnderlying()); 04167 } 04168 04172 inline XnStatus InitFromXmlFile(const XnChar* strFileName, EnumerationErrors* pErrors = NULL) 04173 { 04174 XnStatus nRetVal = xnInitFromXmlFile(strFileName, &m_pContext, pErrors == NULL ? NULL : pErrors->GetUnderlying()); 04175 XN_IS_STATUS_OK(nRetVal); 04176 m_bAllocated = TRUE; 04177 return (XN_STATUS_OK); 04178 } 04179 04183 inline XnStatus OpenFileRecording(const XnChar* strFileName) 04184 { 04185 return xnContextOpenFileRecording(m_pContext, strFileName); 04186 } 04187 04191 inline XnStatus CreateMockNode(XnProductionNodeType type, const XnChar* strName, ProductionNode& node) 04192 { 04193 return xnCreateMockNode(m_pContext, type, strName, &node.m_hNode); 04194 } 04195 04199 inline XnStatus CreateMockNodeBasedOn(ProductionNode& originalNode, const XnChar* strName, ProductionNode& mockNode) 04200 { 04201 return xnCreateMockNodeBasedOn(m_pContext, originalNode.m_hNode, strName, &mockNode.m_hNode); 04202 } 04203 04207 inline XnStatus CreateCodec(XnCodecID codecID, ProductionNode& initializerNode, Codec& codec) 04208 { 04209 return xnCreateCodec(m_pContext, codecID, initializerNode, &codec.m_hNode); 04210 } 04211 04215 inline void Shutdown() 04216 { 04217 if (m_pContext != NULL) 04218 { 04219 xnShutdown(m_pContext); 04220 m_pContext = NULL; 04221 } 04222 } 04223 04227 inline XnStatus AddLicense(const XnLicense& License) 04228 { 04229 return xnAddLicense(m_pContext, &License); 04230 } 04231 04235 inline XnStatus EnumerateLicenses(XnLicense*& aLicenses, XnUInt32& nCount) const 04236 { 04237 return xnEnumerateLicenses(m_pContext, &aLicenses, &nCount); 04238 } 04239 04243 inline static void FreeLicensesList(XnLicense aLicenses[]) 04244 { 04245 return xnFreeLicensesList(aLicenses); 04246 } 04247 04251 XnStatus EnumerateProductionTrees(XnProductionNodeType Type, Query* pQuery, NodeInfoList& TreesList, EnumerationErrors* pErrors = NULL) const 04252 { 04253 XnStatus nRetVal = XN_STATUS_OK; 04254 04255 XnNodeQuery* pInternalQuery = (pQuery != NULL) ? pQuery->GetUnderlyingObject() : NULL; 04256 04257 XnNodeInfoList* pList = NULL; 04258 nRetVal = xnEnumerateProductionTrees(m_pContext, Type, pInternalQuery, &pList, pErrors == NULL ? NULL : pErrors->GetUnderlying()); 04259 XN_IS_STATUS_OK(nRetVal); 04260 04261 TreesList.ReplaceUnderlyingObject(pList); 04262 04263 return (XN_STATUS_OK); 04264 } 04265 04269 XnStatus CreateAnyProductionTree(XnProductionNodeType type, Query* pQuery, ProductionNode& node, EnumerationErrors* pErrors = NULL) 04270 { 04271 XnStatus nRetVal = XN_STATUS_OK; 04272 04273 XnNodeQuery* pInternalQuery = (pQuery != NULL) ? pQuery->GetUnderlyingObject() : NULL; 04274 04275 XnNodeHandle hNode; 04276 nRetVal = xnCreateAnyProductionTree(m_pContext, type, pInternalQuery, &hNode, pErrors == NULL ? NULL : pErrors->GetUnderlying()); 04277 XN_IS_STATUS_OK(nRetVal); 04278 04279 node.SetHandle(hNode); 04280 04281 return (XN_STATUS_OK); 04282 } 04283 04287 XnStatus CreateProductionTree(NodeInfo& Tree) 04288 { 04289 XnStatus nRetVal = XN_STATUS_OK; 04290 04291 XnNodeHandle hNode; 04292 nRetVal = xnCreateProductionTree(m_pContext, Tree, &hNode); 04293 XN_IS_STATUS_OK(nRetVal); 04294 04295 return (XN_STATUS_OK); 04296 } 04297 04301 XnStatus EnumerateExistingNodes(NodeInfoList& list) const 04302 { 04303 XnNodeInfoList* pList; 04304 XnStatus nRetVal = xnEnumerateExistingNodes(m_pContext, &pList); 04305 XN_IS_STATUS_OK(nRetVal); 04306 04307 list.ReplaceUnderlyingObject(pList); 04308 04309 return (XN_STATUS_OK); 04310 } 04311 04315 XnStatus EnumerateExistingNodes(NodeInfoList& list, XnProductionNodeType type) const 04316 { 04317 XnNodeInfoList* pList; 04318 XnStatus nRetVal = xnEnumerateExistingNodesByType(m_pContext, type, &pList); 04319 XN_IS_STATUS_OK(nRetVal); 04320 04321 list.ReplaceUnderlyingObject(pList); 04322 04323 return (XN_STATUS_OK); 04324 } 04325 04329 XnStatus FindExistingNode(XnProductionNodeType type, ProductionNode& node) const 04330 { 04331 XnStatus nRetVal = XN_STATUS_OK; 04332 04333 XnNodeHandle hNode; 04334 nRetVal = xnFindExistingNodeByType(m_pContext, type, &hNode); 04335 XN_IS_STATUS_OK(nRetVal); 04336 04337 node.SetHandle(hNode); 04338 04339 return (XN_STATUS_OK); 04340 } 04341 04345 XnStatus GetProductionNodeByName(const XnChar* strInstanceName, ProductionNode& node) const 04346 { 04347 XnStatus nRetVal = XN_STATUS_OK; 04348 04349 XnNodeHandle hNode; 04350 nRetVal = xnGetNodeHandleByName(m_pContext, strInstanceName, &hNode); 04351 XN_IS_STATUS_OK(nRetVal); 04352 04353 node.SetHandle(hNode); 04354 04355 return (XN_STATUS_OK); 04356 } 04357 04361 XnStatus GetProductionNodeInfoByName(const XnChar* strInstanceName, NodeInfo& nodeInfo) const 04362 { 04363 XnStatus nRetVal = XN_STATUS_OK; 04364 04365 XnNodeHandle hNode; 04366 nRetVal = xnGetNodeHandleByName(m_pContext, strInstanceName, &hNode); 04367 XN_IS_STATUS_OK(nRetVal); 04368 04369 nodeInfo = NodeInfo(xnGetNodeInfo(hNode)); 04370 04371 return (XN_STATUS_OK); 04372 } 04373 04377 inline XnStatus StartGeneratingAll() 04378 { 04379 return xnStartGeneratingAll(m_pContext); 04380 } 04381 04385 inline XnStatus StopGeneratingAll() 04386 { 04387 return xnStopGeneratingAll(m_pContext); 04388 } 04389 04393 inline XnStatus SetGlobalMirror(XnBool bMirror) 04394 { 04395 return xnSetGlobalMirror(m_pContext, bMirror); 04396 } 04397 04401 inline XnBool GetGlobalMirror() 04402 { 04403 return xnGetGlobalMirror(m_pContext); 04404 } 04405 04409 inline XnStatus GetGlobalErrorState() 04410 { 04411 return xnGetGlobalErrorState(m_pContext); 04412 } 04413 04417 inline XnStatus RegisterToErrorStateChange(XnErrorStateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 04418 { 04419 return xnRegisterToGlobalErrorStateChange(m_pContext, handler, pCookie, &hCallback); 04420 } 04421 04425 inline void UnregisterFromErrorStateChange(XnCallbackHandle hCallback) 04426 { 04427 return xnUnregisterFromGlobalErrorStateChange(m_pContext, hCallback); 04428 } 04429 04433 inline XnStatus WaitAndUpdateAll() 04434 { 04435 return xnWaitAndUpdateAll(m_pContext); 04436 } 04437 04441 inline XnStatus WaitAnyUpdateAll() 04442 { 04443 return xnWaitAnyUpdateAll(m_pContext); 04444 } 04445 04449 inline XnStatus WaitOneUpdateAll(ProductionNode& node) 04450 { 04451 return xnWaitOneUpdateAll(m_pContext, node); 04452 } 04453 04457 inline XnStatus WaitNoneUpdateAll() 04458 { 04459 return xnWaitNoneUpdateAll(m_pContext); 04460 } 04461 04465 inline XnStatus AutoEnumerateOverSingleInput(NodeInfoList& List, XnProductionNodeDescription& description, const XnChar* strCreationInfo, XnProductionNodeType InputType, EnumerationErrors* pErrors, Query* pQuery = NULL) const 04466 { 04467 return xnAutoEnumerateOverSingleInput(m_pContext, List.GetUnderlyingObject(), &description, strCreationInfo, InputType, pErrors == NULL ? NULL : pErrors->GetUnderlying(), pQuery == NULL ? NULL : pQuery->GetUnderlyingObject()); 04468 } 04469 04471 inline void SetHandle(XnContext* pContext) 04472 { 04473 if (m_pContext != pContext) 04474 { 04475 FreeImpl(); 04476 m_pContext = pContext; 04477 } 04478 } 04479 04480 private: 04481 void FreeImpl() 04482 { 04483 if (m_bAllocated) 04484 { 04485 Shutdown(); 04486 m_pContext = NULL; 04487 m_bAllocated = FALSE; 04488 } 04489 } 04490 04491 XnContext* m_pContext; 04492 XnBool m_bAllocated; 04493 }; 04494 04499 class Resolution 04500 { 04501 public: 04507 inline Resolution(XnResolution res) : m_Res(res) 04508 { 04509 m_nXRes = xnResolutionGetXRes(res); 04510 m_nYRes = xnResolutionGetYRes(res); 04511 m_strName = xnResolutionGetName(res); 04512 } 04513 04520 inline Resolution(XnUInt32 xRes, XnUInt32 yRes) : m_nXRes(xRes), m_nYRes(yRes) 04521 { 04522 m_Res = xnResolutionGetFromXYRes(xRes, yRes); 04523 m_strName = xnResolutionGetName(m_Res); 04524 } 04525 04531 inline Resolution(const XnChar* strName) 04532 { 04533 m_Res = xnResolutionGetFromName(strName); 04534 m_nXRes = xnResolutionGetXRes(m_Res); 04535 m_nYRes = xnResolutionGetYRes(m_Res); 04536 m_strName = xnResolutionGetName(m_Res); 04537 } 04538 04540 inline XnResolution GetResolution() const { return m_Res; } 04542 inline XnUInt32 GetXResolution() const { return m_nXRes; } 04544 inline XnUInt32 GetYResolution() const { return m_nYRes; } 04546 inline const XnChar* GetName() const { return m_strName; } 04547 04548 private: 04549 XnResolution m_Res; 04550 XnUInt32 m_nXRes; 04551 XnUInt32 m_nYRes; 04552 const XnChar* m_strName; 04553 }; 04554 04555 //--------------------------------------------------------------------------- 04556 // Functions Implementation 04557 //--------------------------------------------------------------------------- 04558 inline XnStatus NodeInfoList::FilterList(Context& context, Query& query) 04559 { 04560 return xnNodeQueryFilterList(context.GetUnderlyingObject(), query.GetUnderlyingObject(), m_pList); 04561 } 04562 04563 inline void ProductionNode::GetContext(Context& context) 04564 { 04565 context.SetHandle(xnGetContextFromNodeHandle(m_hNode)); 04566 } 04567 04568 inline NodeInfoList& NodeInfo::GetNeededNodes() const 04569 { 04570 if (m_pNeededNodes == NULL) 04571 { 04572 XnNodeInfoList* pList = xnNodeInfoGetNeededNodes(m_pInfo); 04573 m_pNeededNodes = XN_NEW(NodeInfoList, pList); 04574 } 04575 04576 return *m_pNeededNodes; 04577 } 04578 04579 inline void NodeInfo::SetUnderlyingObject(XnNodeInfo* pInfo) 04580 { 04581 if (m_pNeededNodes != NULL) 04582 { 04583 XN_DELETE(m_pNeededNodes); 04584 } 04585 04586 m_pInfo = pInfo; 04587 m_pNeededNodes = NULL; 04588 } 04589 04590 inline XnBool FrameSyncCapability::CanFrameSyncWith(Generator& other) 04591 { 04592 return xnCanFrameSyncWith(m_hNode, other); 04593 } 04594 04595 inline XnStatus FrameSyncCapability::FrameSyncWith(Generator& other) 04596 { 04597 return xnFrameSyncWith(m_hNode, other); 04598 } 04599 04600 inline XnStatus FrameSyncCapability::StopFrameSyncWith(Generator& other) 04601 { 04602 return xnStopFrameSyncWith(m_hNode, other); 04603 } 04604 04605 inline XnBool FrameSyncCapability::IsFrameSyncedWith(Generator& other) 04606 { 04607 return xnIsFrameSyncedWith(m_hNode, other); 04608 } 04609 04610 inline XnStatus NodeInfo::GetInstance(ProductionNode& node) const 04611 { 04612 XnStatus nRetVal = XN_STATUS_OK; 04613 04614 if (m_pInfo == NULL) 04615 { 04616 return XN_STATUS_INVALID_OPERATION; 04617 } 04618 04619 node.SetHandle(xnNodeInfoGetHandle(m_pInfo)); 04620 04621 return (XN_STATUS_OK); 04622 } 04623 04624 04625 04626 //--------------------------------------------------------------------------- 04627 // Node creation functions 04628 //--------------------------------------------------------------------------- 04629 04630 inline XnStatus Recorder::Create(Context& context, const XnChar* strFormatName = NULL) 04631 { 04632 return xnCreateRecorder(context.GetUnderlyingObject(), strFormatName, &m_hNode); 04633 } 04634 04635 inline XnStatus Player::Create(Context& context, const XnChar* strFormatName) 04636 { 04637 return xnCreatePlayer(context.GetUnderlyingObject(), strFormatName, &m_hNode); 04638 } 04639 04640 inline XnStatus DepthGenerator::Create(Context& context, Query* pQuery/*=NULL*/, EnumerationErrors* pErrors/*=NULL*/) 04641 { 04642 return xnCreateDepthGenerator(context.GetUnderlyingObject(), &m_hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying()); 04643 } 04644 04645 inline XnStatus MockDepthGenerator::Create(Context& context, const XnChar* strName /* = NULL */) 04646 { 04647 return xnCreateMockNode(context.GetUnderlyingObject(), XN_NODE_TYPE_DEPTH, strName, &m_hNode); 04648 } 04649 04650 inline XnStatus MockDepthGenerator::CreateBasedOn(DepthGenerator& other, const XnChar* strName /* = NULL */) 04651 { 04652 Context context; 04653 other.GetContext(context); 04654 return xnCreateMockNodeBasedOn(context.GetUnderlyingObject(), other, strName, &m_hNode); 04655 } 04656 04657 inline XnStatus ImageGenerator::Create(Context& context, Query* pQuery/*=NULL*/, EnumerationErrors* pErrors/*=NULL*/) 04658 { 04659 return xnCreateImageGenerator(context.GetUnderlyingObject(), &m_hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying()); 04660 } 04661 04662 inline XnStatus MockImageGenerator::Create(Context& context, const XnChar* strName /* = NULL */) 04663 { 04664 return xnCreateMockNode(context.GetUnderlyingObject(), XN_NODE_TYPE_IMAGE, strName, &m_hNode); 04665 } 04666 04667 inline XnStatus MockImageGenerator::CreateBasedOn(ImageGenerator& other, const XnChar* strName /* = NULL */) 04668 { 04669 Context context; 04670 other.GetContext(context); 04671 return xnCreateMockNodeBasedOn(context.GetUnderlyingObject(), other, strName, &m_hNode); 04672 } 04673 04674 inline XnStatus IRGenerator::Create(Context& context, Query* pQuery/*=NULL*/, EnumerationErrors* pErrors/*=NULL*/) 04675 { 04676 return xnCreateIRGenerator(context.GetUnderlyingObject(), &m_hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying()); 04677 } 04678 04679 inline XnStatus MockIRGenerator::Create(Context& context, const XnChar* strName /* = NULL */) 04680 { 04681 return xnCreateMockNode(context.GetUnderlyingObject(), XN_NODE_TYPE_IR, strName, &m_hNode); 04682 } 04683 04684 inline XnStatus MockIRGenerator::CreateBasedOn(IRGenerator& other, const XnChar* strName /* = NULL */) 04685 { 04686 Context context; 04687 other.GetContext(context); 04688 return xnCreateMockNodeBasedOn(context.GetUnderlyingObject(), other, strName, &m_hNode); 04689 } 04690 04691 inline XnStatus GestureGenerator::Create(Context& context, Query* pQuery/*=NULL*/, EnumerationErrors* pErrors/*=NULL*/) 04692 { 04693 return xnCreateGestureGenerator(context.GetUnderlyingObject(), &m_hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying()); 04694 } 04695 04696 inline XnStatus SceneAnalyzer::Create(Context& context, Query* pQuery/*=NULL*/, EnumerationErrors* pErrors/*=NULL*/) 04697 { 04698 //You're creating a scene! 04699 return xnCreateSceneAnalyzer(context.GetUnderlyingObject(), &m_hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying()); 04700 } 04701 04702 inline XnStatus HandsGenerator::Create(Context& context, Query* pQuery/*=NULL*/, EnumerationErrors* pErrors/*=NULL*/) 04703 { 04704 return xnCreateHandsGenerator(context.GetUnderlyingObject(), &m_hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying()); 04705 } 04706 04707 inline XnStatus UserGenerator::Create(Context& context, Query* pQuery/*=NULL*/, EnumerationErrors* pErrors/*=NULL*/) 04708 { 04709 return xnCreateUserGenerator(context.GetUnderlyingObject(), &m_hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying()); 04710 } 04711 04712 inline XnStatus AudioGenerator::Create(Context& context, Query* pQuery/*=NULL*/, EnumerationErrors* pErrors/*=NULL*/) 04713 { 04714 return xnCreateAudioGenerator(context.GetUnderlyingObject(), &m_hNode, pQuery == NULL ? NULL : pQuery->GetUnderlyingObject(), pErrors == NULL ? NULL : pErrors->GetUnderlying()); 04715 } 04716 04717 inline XnStatus MockAudioGenerator::Create(Context& context, const XnChar* strName /* = NULL */) 04718 { 04719 return xnCreateMockNode(context.GetUnderlyingObject(), XN_NODE_TYPE_AUDIO, strName, &m_hNode); 04720 } 04721 04722 inline XnStatus MockAudioGenerator::CreateBasedOn(AudioGenerator& other, const XnChar* strName /* = NULL */) 04723 { 04724 Context context; 04725 other.GetContext(context); 04726 return xnCreateMockNodeBasedOn(context.GetUnderlyingObject(), other, strName, &m_hNode); 04727 } 04728 04729 inline XnStatus Codec::Create(Context& context, XnCodecID codecID, ProductionNode& initializerNode) 04730 { 04731 return xnCreateCodec(context.GetUnderlyingObject(), codecID, initializerNode, &m_hNode); 04732 } 04733 04734 //--------------------------------------------------------------------------- 04735 // Global Helper Functions 04736 //--------------------------------------------------------------------------- 04737 04741 inline void GetVersion(XnVersion& Version) 04742 { 04743 xnGetVersion(&Version); 04744 } 04745 04746 //--------------------------------------------------------------------------- 04747 // Internal Helper Classes and Functions 04748 //--------------------------------------------------------------------------- 04749 04750 class StateChangedCallbackTranslator 04751 { 04752 public: 04753 StateChangedCallbackTranslator(StateChangedHandler handler, void* pCookie) : m_UserHandler(handler), m_pUserCookie(pCookie), m_hCallback(NULL) {} 04754 04755 XnStatus Register(_XnRegisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode) 04756 { 04757 return xnFunc(hNode, StateChangedCallback, this, &m_hCallback); 04758 } 04759 04760 void Unregister(_XnUnregisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode) 04761 { 04762 xnFunc(hNode, m_hCallback); 04763 } 04764 04765 static XnStatus RegisterToUnderlying(_XnRegisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode, StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 04766 { 04767 XnStatus nRetVal = XN_STATUS_OK; 04768 04769 StateChangedCallbackTranslator* pTrans; 04770 XN_VALIDATE_NEW(pTrans, StateChangedCallbackTranslator, handler, pCookie); 04771 04772 nRetVal = pTrans->Register(xnFunc, hNode); 04773 if (nRetVal != XN_STATUS_OK) 04774 { 04775 XN_DELETE(pTrans); 04776 return (nRetVal); 04777 } 04778 04779 hCallback = pTrans; 04780 04781 return (XN_STATUS_OK); 04782 } 04783 04784 static XnStatus UnregisterFromUnderlying(_XnUnregisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode, XnCallbackHandle hCallback) 04785 { 04786 StateChangedCallbackTranslator* pTrans = (StateChangedCallbackTranslator*)hCallback; 04787 pTrans->Unregister(xnFunc, hNode); 04788 XN_DELETE(pTrans); 04789 return XN_STATUS_OK; 04790 } 04791 04792 private: 04793 typedef struct StateChangeCookie 04794 { 04795 StateChangedHandler userHandler; 04796 void* pUserCookie; 04797 XnCallbackHandle hCallback; 04798 } StateChangeCookie; 04799 04800 static void XN_CALLBACK_TYPE StateChangedCallback(XnNodeHandle hNode, void* pCookie) 04801 { 04802 StateChangedCallbackTranslator* pTrans = (StateChangedCallbackTranslator*)pCookie; 04803 ProductionNode node(hNode); 04804 pTrans->m_UserHandler(node, pTrans->m_pUserCookie); 04805 } 04806 04807 StateChangedHandler m_UserHandler; 04808 void* m_pUserCookie; 04809 XnCallbackHandle m_hCallback; 04810 }; 04811 04812 static XnStatus _RegisterToStateChange(_XnRegisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode, StateChangedHandler handler, void* pCookie, XnCallbackHandle& hCallback) 04813 { 04814 return StateChangedCallbackTranslator::RegisterToUnderlying(xnFunc, hNode, handler, pCookie, hCallback); 04815 } 04816 04817 static void _UnregisterFromStateChange(_XnUnregisterStateChangeFuncPtr xnFunc, XnNodeHandle hNode, XnCallbackHandle hCallback) 04818 { 04819 StateChangedCallbackTranslator::UnregisterFromUnderlying(xnFunc, hNode, hCallback); 04820 } 04821 04823 }; 04824 04825 #endif // __XN_CPP_WRAPPER_H__