00001
00008 #include "OpenNiDevice.h"
00009 #include "tools++.h"
00010
00011
00012 using namespace jbxl;
00013
00014
00015
00016 #ifdef ENABLE_OPENNI
00017
00018
00019
00020 COpenNiDevice::COpenNiDevice(void)
00021 {
00022 context = NULL;
00023 image = NULL;
00024 user = NULL;
00025 depth = NULL;
00026 player = NULL;
00027
00028 imageMD = NULL;
00029 depthMD = NULL;
00030 sceneMD = NULL;
00031
00032 m_enu_dev = EnuDev_Unknown;
00033 m_has_camera = TRUE;
00034 m_err_mesg = make_Buffer(LMESG);
00035
00036 m_state = NI_STATE_DETECT_STOPPED;
00037 m_xsize = OPENNI_DEPTH_XSIZE;
00038 m_ysize = OPENNI_DEPTH_YSIZE;
00039 m_nfps = OPENNI_DEPTH_FPS;
00040
00041
00042 recorder = NULL;
00043 skeleton = NULL;
00044
00045
00046 usb_dev = NULL;
00047 devPath = NULL;
00048
00049 userCallbacks = NULL;
00050 poseCallbacks = NULL;
00051 calibCallbacks = NULL;
00052
00053 memset(dUsers, 0, sizeof(XnUserID)*OPENNI_USERS_NUM);
00054 }
00055
00056
00057
00058 BOOL COpenNiDevice::init(BOOL use_image)
00059 {
00060 outputMode.nXRes = OPENNI_DEPTH_XSIZE;
00061 outputMode.nYRes = OPENNI_DEPTH_YSIZE;
00062 outputMode.nFPS = OPENNI_DEPTH_FPS;
00063
00064 m_enu_dev = EnuDev_None;
00065
00066 BOOL ret = create_Context();
00067 if (ret && use_image) create_Image();
00068 if (ret) ret = create_Depth();
00069 if (ret) m_enu_dev = EnuDev_PS1080;
00070
00071 return ret;
00072 }
00073
00074
00075
00076 BOOL COpenNiDevice::init(char* fname, BOOL use_image)
00077 {
00078 m_enu_dev = EnuDev_None;
00079
00080 if (fname==NULL) {
00081 copy_s2Buffer("COpenNiDevice::init ERROR: File name is NULL", &m_err_mesg);
00082 return FALSE;
00083 }
00084
00085
00086 BOOL ret = create_Context(fname);
00087 if (ret) ret = create_Player(TRUE);
00088 if (!ret) {
00089 copy_s2Buffer("COpenNiDevice::init ERROR: create error!!", &m_err_mesg);
00090 return FALSE;
00091 }
00092
00093
00094 xn::NodeInfoList nodeList;
00095 player->EnumerateNodes(nodeList);
00096
00097 for (xn::NodeInfoList::Iterator node=nodeList.Begin(); node!=nodeList.End(); node++) {
00098 if ((*node).GetDescription().Type==XN_NODE_TYPE_IMAGE) {
00099 if (use_image) {
00100 ret = create_Image(TRUE);
00101 if (!ret) break;
00102 }
00103 }
00104 if ((*node).GetDescription().Type==XN_NODE_TYPE_DEPTH) {
00105 ret = create_Depth(TRUE);
00106 if (!ret) break;
00107 }
00108 }
00109
00110
00111 if (image!=NULL && use_image) {
00112 image->GetMapOutputMode(outputMode);
00113 }
00114 else if (depth!=NULL) {
00115 depth->GetMapOutputMode(outputMode);
00116 }
00117 else {
00118 copy_s2Buffer("COpenNiDevice::init ERROR: No Generators", &m_err_mesg);
00119 return FALSE;
00120 }
00121
00122 m_enu_dev = EnuDev_OniFile;
00123 return TRUE;
00124 }
00125
00126
00127
00128 void COpenNiDevice::free(void)
00129 {
00130 clear_Tracking();
00131 clear_CallBacks();
00132 clear_Skeleton();
00133
00134 delete_User();
00135 delete_Depth();
00136 delete_Image();
00137 delete_Player();
00138 delete_Context();
00139
00140 free_Buffer(&m_err_mesg);
00141 }
00142
00143
00144
00145
00147
00148
00149 BOOL COpenNiDevice::create_Context(char* fname)
00150 {
00151 if (context==NULL) {
00152 context = new xn::Context();
00153 if (context==NULL) {
00154 copy_s2Buffer("COpenNiDevice::create_Context ERROR: context is NULL", &m_err_mesg);
00155 return FALSE;
00156 }
00157 }
00158
00159 XnStatus rc = context->Init();
00160 if (rc==XN_STATUS_OK && fname!=NULL) rc = context->OpenFileRecording(fname);
00161
00162 if (rc!=XN_STATUS_OK) {
00163 copy_s2Buffer("COpenNiDevice::create_Context ERROR: ", &m_err_mesg);
00164 cat_s2Buffer (::xnGetStatusString(rc), &m_err_mesg);
00165 return FALSE;
00166 }
00167
00168 return TRUE;
00169 }
00170
00171
00172
00173 BOOL COpenNiDevice::create_Image(BOOL easy)
00174 {
00175 if (!m_has_camera) return FALSE;
00176
00177 if (context==NULL) {
00178 copy_s2Buffer("COpenNiDevice::create_Image ERROR: context is NULL", &m_err_mesg);
00179 return FALSE;
00180 }
00181
00182 if (image==NULL) {
00183 image = new xn::ImageGenerator();
00184 if (image==NULL) {
00185 copy_s2Buffer("COpenNiDevice::create_Image ERROR: fail to create image generator", &m_err_mesg);
00186 m_has_camera = FALSE;
00187 return FALSE;
00188 }
00189 }
00190
00191 XnStatus rc = XN_STATUS_ERROR;
00192 if (easy) {
00193 rc = context->FindExistingNode(XN_NODE_TYPE_IMAGE, *image);
00194 }
00195 else {
00196 rc = image->Create(*context);
00197 if (rc==XN_STATUS_OK) rc = image->StartGenerating();
00198 if (rc==XN_STATUS_OK) rc = image->SetMapOutputMode(outputMode);
00199 }
00200
00201 if (rc!=XN_STATUS_OK) {
00202 copy_s2Buffer("COpenNiDevice::create_Image ERROR: ", &m_err_mesg);
00203 cat_s2Buffer (::xnGetStatusString(rc), &m_err_mesg);
00204 delete_Image();
00205 return FALSE;
00206 }
00207
00208 imageMD = new xn::ImageMetaData();
00209
00210
00211 return TRUE;
00212 }
00213
00214
00215
00216 BOOL COpenNiDevice::create_Depth(BOOL easy)
00217 {
00218 if (context==NULL) {
00219 copy_s2Buffer("COpenNiDevice::create_Depth ERROR: context is NULL", &m_err_mesg);
00220 return FALSE;
00221 }
00222
00223 if (depth==NULL) {
00224 depth = new xn::DepthGenerator();
00225 if (depth==NULL) {
00226 copy_s2Buffer("COpenNiDevice::create_Depth ERROR: fail to create depth generator", &m_err_mesg);
00227 return FALSE;
00228 }
00229 }
00230
00231 XnStatus rc = XN_STATUS_ERROR;
00232 if (easy) {
00233 rc = context->FindExistingNode(XN_NODE_TYPE_DEPTH, *depth);
00234 }
00235 else {
00236 rc = depth->Create(*context);
00237 if (rc==XN_STATUS_OK) rc = depth->StartGenerating();
00238 if (rc==XN_STATUS_OK) rc = depth->SetMapOutputMode(outputMode);
00239 if (rc==XN_STATUS_OK && image!=NULL) {
00240 rc = depth->GetAlternativeViewPointCap().SetViewPoint(*image);
00241
00242
00243
00244
00245
00246 }
00247 }
00248
00249 if (rc!=XN_STATUS_OK) {
00250 copy_s2Buffer("COpenNiDevice::create_Depth ERROR: ", &m_err_mesg);
00251 cat_s2Buffer (::xnGetStatusString(rc), &m_err_mesg);
00252 delete_Depth();
00253 return FALSE;
00254 }
00255
00256 depthMD = new xn::DepthMetaData();
00257
00258
00259 return TRUE;
00260 }
00261
00262
00263
00264 BOOL COpenNiDevice::create_User(BOOL easy)
00265 {
00266 if (context==NULL) {
00267 copy_s2Buffer("COpenNiDevice::create_User ERROR: context is NULL", &m_err_mesg);
00268 return FALSE;
00269 }
00270
00271 if (user==NULL) {
00272 user = new xn::UserGenerator();
00273 if (user==NULL) {
00274 copy_s2Buffer("COpenNiDevice::create_User ERROR: fail to create user generator", &m_err_mesg);
00275 return FALSE;
00276 }
00277 }
00278
00279 XnStatus rc = XN_STATUS_ERROR;
00280 if (easy) {
00281 rc = context->FindExistingNode(XN_NODE_TYPE_USER, *user);
00282 }
00283 else {
00284 rc = user->Create(*context);
00285 if (rc==XN_STATUS_OK) rc = user->StartGenerating();
00286 }
00287
00288 if (rc!=XN_STATUS_OK) {
00289 copy_s2Buffer("COpenNiDevice::create_User ERROR: ", &m_err_mesg);
00290 cat_s2Buffer (::xnGetStatusString(rc), &m_err_mesg);
00291 delete_User();
00292 return FALSE;
00293 }
00294
00295 sceneMD = new xn::SceneMetaData();
00296 return TRUE;
00297 }
00298
00299
00300
00301 BOOL COpenNiDevice::create_Player(BOOL easy)
00302 {
00303 if (context==NULL) {
00304 copy_s2Buffer("COpenNiDevice::create_Player ERROR: context is NULL", &m_err_mesg);
00305 return FALSE;
00306 }
00307
00308 if (player==NULL) {
00309 player = new xn::Player();
00310 if (player==NULL) {
00311 copy_s2Buffer("COpenNiDevice::create_Player ERROR: fail to create player generator", &m_err_mesg);
00312 return FALSE;
00313 }
00314 }
00315
00316 XnStatus rc = XN_STATUS_ERROR;
00317 if (easy) {
00318 rc = context->FindExistingNode(XN_NODE_TYPE_PLAYER, *player);
00319 }
00320 else {
00321 rc = player->Create(*context, "oni");
00322 }
00323
00324 if (rc!=XN_STATUS_OK) {
00325 copy_s2Buffer("COpenNiDevice::create_Player EROR: ", &m_err_mesg);
00326 cat_s2Buffer (::xnGetStatusString(rc), &m_err_mesg);
00327 delete_Player();
00328 return FALSE;
00329 }
00330
00331 return TRUE;
00332 }
00333
00334
00335
00336
00338
00339
00340 void COpenNiDevice::delete_Context(void)
00341 {
00342 if (context!=NULL) {
00343 context->Release();
00344 delete(context);
00345 }
00346 context = NULL;
00347 }
00348
00349
00350
00351 void COpenNiDevice::delete_Image(void)
00352 {
00353 if (image!=NULL) {
00354 if (image->IsValid()) {
00355 if (image->IsGenerating()) image->StopGenerating();
00356 }
00357 image->Release();
00358 delete(image);
00359 }
00360 if (imageMD!=NULL) delete(imageMD);
00361
00362 image = NULL;
00363 imageMD = NULL;
00364 }
00365
00366
00367
00368 void COpenNiDevice::delete_Depth(void)
00369 {
00370 if (depth!=NULL) {
00371 if (depth->IsValid()) {
00372 if (depth->IsGenerating()) depth->StopGenerating();
00373 }
00374 depth->Release();
00375 delete(depth);
00376 }
00377 if (depthMD!=NULL) delete(depthMD);
00378
00379 depth = NULL;
00380 depthMD = NULL;
00381 }
00382
00383
00384
00385 void COpenNiDevice::delete_User(void)
00386 {
00387 if (user!=NULL) {
00388 if (user->IsValid()) {
00389 if (user->IsGenerating()) user->StopGenerating();
00390 }
00391 user->Release();
00392 delete(user);
00393 }
00394 if (sceneMD!=NULL) delete(sceneMD);
00395
00396 user = NULL;
00397 sceneMD = NULL;
00398 }
00399
00400
00401
00402 void COpenNiDevice::delete_Player(void)
00403 {
00404 if (player!=NULL) {
00405 player->Release();
00406 delete(player);
00407 player = NULL;
00408 }
00409 }
00410
00411
00412
00413
00415
00416
00417 BOOL COpenNiDevice::setup_Tracking(int profile, double smooth)
00418 {
00419 if (user==NULL) {
00420 copy_s2Buffer("COpenNiDevice::setup_Tracking ERROR: user is NULL", &m_err_mesg);
00421 return FALSE;
00422 }
00423 if (!user->IsCapabilitySupported(XN_CAPABILITY_SKELETON)) {
00424 copy_s2Buffer("COpenNiDevice::setup_Tracking ERROR: not support skeleton", &m_err_mesg);
00425 return FALSE;
00426 }
00427
00428 if (skeleton==NULL) {
00429 skeleton = new xn::SkeletonCapability(*user);
00430 if (skeleton==NULL) {
00431 copy_s2Buffer("COpenNiDevice::setup_Tracking ERROR: fail to make skeleton capability", &m_err_mesg);
00432 return FALSE;
00433 }
00434 }
00435
00436
00437 skeleton->SetSkeletonProfile((XnSkeletonProfile)profile);
00438 skeleton->SetSmoothing((XnFloat)smooth);
00439
00440 return TRUE;
00441 }
00442
00443
00444
00445
00447
00448
00449
00450 void COpenNiDevice::clear_Skeleton(void)
00451 {
00452 if (skeleton!=NULL) delete(skeleton);
00453 skeleton = NULL;
00454 }
00455
00456
00457
00458 void COpenNiDevice::clear_Tracking(void)
00459 {
00460 if (user!=NULL) {
00461 nUsers = OPENNI_USERS_NUM;
00462 user->GetUsers(dUsers, nUsers);
00463 for (int i=0; i<nUsers; i++) {
00464 if (skeleton!=NULL && skeleton->IsTracking(dUsers[i])) {
00465 skeleton->StopTracking(dUsers[i]);
00466 }
00467 }
00468 }
00469 }
00470
00471
00472
00473
00475
00476
00477 BOOL COpenNiDevice::create_Recorder(char* file_name, BOOL use_image)
00478 {
00479 if (context==NULL) {
00480 copy_s2Buffer("COpenNiDevice::create_Recorder ERROR: context is NULL", &m_err_mesg);
00481 return FALSE;
00482 }
00483 if (depth==NULL) {
00484 copy_s2Buffer("COpenNiDevice::create_Recorder ERROR: depth is NULL", &m_err_mesg);
00485 return FALSE;
00486 }
00487
00488 recorder = new xn::Recorder();
00489 rc = recorder->Create(*context);
00490 if (rc==XN_STATUS_OK) rc = recorder->SetDestination(XN_RECORD_MEDIUM_FILE, file_name);
00491 if (rc==XN_STATUS_OK && use_image && image!=NULL) rc = recorder->AddNodeToRecording(*image, XN_CODEC_JPEG);
00492 if (rc==XN_STATUS_OK) rc = recorder->AddNodeToRecording(*depth, XN_CODEC_16Z);
00493
00494 if (rc!=XN_STATUS_OK) {
00495 copy_s2Buffer("COpenNiDevice::create_Recorder ERROR: ", &m_err_mesg);
00496 cat_s2Buffer (::xnGetStatusString(rc), &m_err_mesg);
00497 return FALSE;
00498 }
00499
00500 return TRUE;
00501 }
00502
00503
00504
00505 void COpenNiDevice::delete_Recorder(void)
00506 {
00507 if (recorder!=NULL) {
00508 int prev_state = m_state;
00509 m_state = NI_STATE_SAVE_WORKING;
00510 {
00511 Sleep(NI_WORKING_WAIT_TIME);
00512 if (depth!=NULL) recorder->RemoveNodeFromRecording(*depth);
00513 if (image!=NULL) recorder->RemoveNodeFromRecording(*image);
00514
00515 recorder->Release();
00516 delete(recorder);
00517 }
00518 m_state = prev_state;
00519 }
00520 recorder = NULL;
00521 }
00522
00523
00524
00525 BOOL COpenNiDevice::start_Recorde(char* file_name, BOOL use_image)
00526 {
00527 BOOL ret = FALSE;
00528 unlink(file_name);
00529
00530 int prev_state = m_state;
00531 m_state = NI_STATE_SAVE_WORKING;
00532 {
00533 Sleep(NI_WORKING_WAIT_TIME);
00534 ret = create_Recorder(file_name, use_image);
00535 if (ret) {
00536 rc = recorder->Record();
00537 if (rc!=XN_STATUS_OK) {
00538 copy_s2Buffer("COpenNiDevice::start_Recorde ERROR: ", &m_err_mesg);
00539 cat_s2Buffer (::xnGetStatusString(rc), &m_err_mesg);
00540 ret = FALSE;
00541 }
00542 }
00543 }
00544 m_state = prev_state;
00545
00546 if (!ret) {
00547 delete_Recorder();
00548 unlink(file_name);
00549 }
00550 return ret;
00551 }
00552
00553
00554
00555 void COpenNiDevice::stop_Recorde(void)
00556 {
00557 delete_Recorder();
00558 }
00559
00560
00561
00562
00564
00565
00566 BOOL COpenNiDevice::open_USB_Device(void)
00567 {
00568 rc = ::xnUSBInit();
00569 if (rc!=XN_STATUS_OK && rc!=XN_STATUS_USB_ALREADY_INIT) return FALSE;
00570
00571 #ifdef WIN32
00572
00573 XnUInt32 count;
00574 rc = ::xnUSBEnumerateDevices(NI_VID_MICROSOFT, NI_PID_NUI_MOTOR, (const XnUSBConnectionString**)&devPath, &count);
00575 if (rc!=XN_STATUS_OK) {
00576 ::xnUSBShutdown();
00577 return FALSE;
00578 }
00579
00580 rc = ::xnUSBOpenDeviceByPath(*devPath, &usb_dev);
00581 if (rc!=XN_STATUS_OK) {
00582 ::xnUSBFreeDevicesList(devPath);
00583 return FALSE;
00584 }
00585
00586 #else
00587
00588 rc = ::xnUSBOpenDevice(OPENNI_VID_MICROSOFT, OPENNI_PID_NUI_MOTOR, NULL, NULL, &usb_dev);
00589 if (rc!=XN_STATUS_OK) {
00590 ::xnUSBShutdown();
00591 return FALSE;
00592 }
00593
00594 #endif
00595
00596 return TRUE;
00597 }
00598
00599
00600
00601 void COpenNiDevice::close_USB_Device(void)
00602 {
00603 if (usb_dev!=NULL) {
00604 ::xnUSBCloseDevice(usb_dev);
00605 usb_dev = NULL;
00606 }
00607
00608 #ifdef WIN32
00609
00610 if (devPath!=NULL) {
00611 ::xnUSBFreeDevicesList(devPath);
00612 devPath = NULL;
00613 }
00614
00615 #endif
00616
00617 ::xnUSBShutdown();
00618 }
00619
00620
00621
00622 void COpenNiDevice::set_LED_Color(int col)
00623 {
00624 if (usb_dev==NULL) return;
00625
00626 ::xnUSBSendControl(usb_dev, XN_USB_CONTROL_TYPE_VENDOR, 0x06, (XnUInt16)col, 0, NULL, 0, 0);
00627
00628 return;
00629 }
00630
00631
00632
00633 void COpenNiDevice::set_Tilt_Motor(int ang)
00634 {
00635 if (usb_dev==NULL) return;
00636
00637
00638 ::xnUSBSendControl(usb_dev, XN_USB_CONTROL_TYPE_VENDOR, 0x31, (XnUInt16)(ang*2), 0, NULL, 0, 0);
00639
00640
00641 Sleep(1000);
00642 return;
00643 }
00644
00645
00646
00647
00649
00650
00652 BOOL COpenNiDevice::setup_CallBacks()
00653 {
00654 BOOL ret = set_UserCallbacks (&userDetect, &userLost, this);
00655 if (ret) ret = set_CalibCallbacks(&calibStart, &calibEnd, this);
00656 if (!ret) return FALSE;
00657
00658 return TRUE;
00659 }
00660
00661
00662
00663 void COpenNiDevice::clear_CallBacks()
00664 {
00665 unset_UserCallbacks();
00666 unset_CalibCallbacks();
00667 }
00668
00669
00670
00671 BOOL COpenNiDevice::set_UserCallbacks(xn::UserGenerator::UserHandler newUser, xn::UserGenerator::UserHandler lostUser, void* cookie)
00672 {
00673 if (user==NULL) {
00674 copy_s2Buffer("COpenNiDevice::set_UserCallbacks ERROR: user is NULL", &m_err_mesg);
00675 return FALSE;
00676 }
00677
00678 rc = user->RegisterUserCallbacks(newUser, lostUser, cookie, userCallbacks);
00679 if (rc!=XN_STATUS_OK) {
00680 copy_s2Buffer("COpenNiDevice::set_UserCallbacks ERROR: ", &m_err_mesg);
00681 cat_s2Buffer (::xnGetStatusString(rc), &m_err_mesg);
00682 unset_UserCallbacks();
00683 return FALSE;
00684 }
00685 return TRUE;
00686 }
00687
00688
00689
00690 BOOL COpenNiDevice::set_CalibCallbacks(xn::SkeletonCapability::CalibrationStart calibStart, xn::SkeletonCapability::CalibrationEnd calibEnd, void* cookie)
00691 {
00692 if (skeleton==NULL) {
00693 copy_s2Buffer("COpenNiDevice::set_CalibCallbacks ERROR: skeleton is NULL", &m_err_mesg);
00694 return FALSE;
00695 }
00696
00697 rc = skeleton->RegisterCalibrationCallbacks(calibStart, calibEnd, cookie, calibCallbacks);
00698 if (rc!=XN_STATUS_OK) {
00699 copy_s2Buffer("COpenNiDevice::set_CalibCallbacks ERROR: ", &m_err_mesg);
00700 cat_s2Buffer (::xnGetStatusString(rc), &m_err_mesg);
00701 unset_CalibCallbacks();
00702 return FALSE;
00703 }
00704 return TRUE;
00705 }
00706
00707
00708
00709 void COpenNiDevice::unset_UserCallbacks()
00710 {
00711 if (user!=NULL && userCallbacks!=NULL) {
00712 user->UnregisterUserCallbacks(userCallbacks);
00713 userCallbacks = NULL;
00714 }
00715 return;
00716 }
00717
00718
00719
00720 void COpenNiDevice::unset_CalibCallbacks()
00721 {
00722 if (skeleton!=NULL && calibCallbacks!=NULL) {
00723 skeleton->UnregisterCalibrationCallbacks(calibCallbacks);
00724 calibCallbacks = NULL;
00725 }
00726 return;
00727 }
00728
00729
00730
00731
00733
00734
00735
00736 void XN_CALLBACK_TYPE jbxl::userDetect(xn::UserGenerator& user, unsigned int nId, void* cookie)
00737 {
00738 DEBUG_INFO("jbxl::userDetect(): User is detected. (%d)", nId);
00739 if (cookie==NULL) return;
00740
00741 user.GetSkeletonCap().RequestCalibration(nId, TRUE);
00742
00743 DEBUG_INFO("jbxl::userDetect(): Start Pose Detection. (%d)", nId);
00744 }
00745
00746
00747
00748 void XN_CALLBACK_TYPE jbxl::userLost(xn::UserGenerator& user, unsigned int nId, void* cookie)
00749 {
00750 DEBUG_INFO("jbxl::userLost(): Lost user. (%d)", nId);
00751
00752 if (user.GetSkeletonCap().IsValid()) {
00753 if (user.GetSkeletonCap().IsTracking(nId)) {
00754 user.GetSkeletonCap().StopTracking(nId);
00755 DEBUG_INFO("jbxl::userLost(): Stop Tracking. (%d)", nId);
00756 }
00757 }
00758 }
00759
00760
00761
00762
00763
00764 void XN_CALLBACK_TYPE jbxl::calibStart(xn::SkeletonCapability& skeleton, unsigned int nId, void* cookie)
00765 {
00766 DEBUG_INFO("jbxl::calibStart(): Start Calibration. (%d)", nId);
00767 }
00768
00769
00770
00771 void XN_CALLBACK_TYPE jbxl::calibEnd(xn::SkeletonCapability& skeleton, unsigned int nId, XnBool success, void* cookie)
00772 {
00773 DEBUG_INFO("jbxl::calibEnd(): End Calibration. (%d)", nId);
00774 if (cookie==NULL) return;
00775
00776
00777 xn::UserGenerator* user = ((COpenNiDevice*)cookie)->user;
00778 if (user!=NULL) {
00779 if (success) {
00780 if (user!=NULL) {
00781 user->GetSkeletonCap().StartTracking(nId);
00782 DEBUG_INFO("jbxl::calibEnd(): Start Tracking. (%d)", nId);
00783 }
00784 }
00785 }
00786 }
00787
00788
00789 #endif // ENABLE_OPENNI
