JunkBox_Lib++ (for Windows): NiLib/OpenNi2Device.cpp Source File

00001 
00005 #include  "OpenNi2Device.h"
00006 
00007 
00008 #ifdef  ENABLE_OPENNI2
00009 
00010 
00011 using namespace jbxl;
00012 
00013 
00014 COpenNi2Device::COpenNi2Device(void)
00015 {
00016     context      = NULL;
00017     recorder     = NULL;
00018 
00019     image        = NULL;
00020     depth        = NULL;
00021 //  audio        = NULL;
00022     user         = NULL;
00023 
00024     m_enu_dev    = EnuDev_Unknown;
00025     m_has_camera = TRUE;
00026     m_err_mesg   = make_Buffer(LMESG);
00027 
00028     m_state      = NI_STATE_DETECT_STOPPED;
00029     m_xsize      = OPENNI_DEPTH_XSIZE;
00030     m_ysize      = OPENNI_DEPTH_YSIZE;
00031     m_nfps       = OPENNI_DEPTH_FPS;
00032 
00033     //
00034     m_has_image_data = TRUE;
00035     m_has_depth_data = TRUE;
00036 //  m_has_audio_data = TRUE;
00037 
00038     // Video Mode
00039     imageMode.setFps(m_nfps);
00040     imageMode.setResolution(m_xsize, m_ysize);
00041     imageMode.setPixelFormat(openni::PIXEL_FORMAT_RGB888);
00042 
00043     depthMode.setFps(m_nfps);
00044     depthMode.setResolution(m_xsize, m_ysize);
00045     depthMode.setPixelFormat(openni::PIXEL_FORMAT_DEPTH_1_MM);
00046 }
00047 
00048 
00049 
00050 BOOL  COpenNi2Device::init(BOOL use_image)
00051 {
00052     m_stream_flg = 0x00; 
00053     m_stream_num = 0;
00054     for (int s=0; s<OPENNI2_STREAM_DATA_NUM; s++) m_streams[s] = NULL;
00055 
00056     m_enu_dev = EnuDev_None;
00057 
00058     BOOL ret = create_Context();
00059     if (ret && use_image) ret = create_Image();
00060     if (ret) ret = create_Depth();
00061     if (ret) {
00062         const openni::DeviceInfo info = context->getDeviceInfo();
00063         DEBUG_INFO("COpenNi2Device::init(): INFO: Device Name = %s", info.getName());
00064         //
00065         if      (!strcasecmp(info.getName(), OPENNI2_DEVICE_PS1080))  m_enu_dev = EnuDev_PS1080;
00066         else if (!strcasecmp(info.getName(), OPENNI2_DEVICE_KINECT))  m_enu_dev = EnuDev_Kinect;
00067         else if (!strcasecmp(info.getName(), OPENNI2_DEVICE_ONIFILE)) m_enu_dev = EnuDev_OniFile;
00068     }
00069 
00070     return ret;
00071 }
00072 
00073 
00074 
00075 BOOL  COpenNi2Device::init(char* fname, BOOL use_image)
00076 {
00077     m_enu_dev = EnuDev_None;
00078 
00079     if (fname==NULL) {
00080         copy_s2Buffer("COpenNi2Device::init(): ERROR: File name is NULL.", &m_err_mesg);
00081         return FALSE;
00082     }
00083 
00084     m_stream_flg = 0x00; 
00085     m_stream_num = 0;
00086     for (int s=0; s<OPENNI2_STREAM_DATA_NUM; s++) m_streams[s] = NULL;
00087 
00088     BOOL ret = create_Context(fname);
00089     if (ret && use_image) ret = create_Image();
00090     if (ret) ret = create_Depth();
00091     if (ret) m_enu_dev = EnuDev_OniFile;
00092 
00093     return ret;
00094 }
00095 
00096 
00097 
00098 void  COpenNi2Device::free(void)
00099 {
00100     DEBUG_LOG("COpenNi2Device::free(): deleting Recorder ...");
00101     delete_Recorder();
00102     //
00103     DEBUG_LOG("COpenNi2Device::free(): deleting Image ...");
00104     delete_Image();
00105     DEBUG_LOG("COpenNi2Device::free(): deleting Depth ...");
00106     delete_Depth();
00107     DEBUG_LOG("COpenNi2Device::free(): deleting Context ...");
00108     delete_Context();
00109     DEBUG_LOG("COpenNi2Device::free(): deleted Generators.");
00110     //
00111     free_Buffer(&m_err_mesg);
00112 
00113     DEBUG_LOG("COpenNi2Device::free(): END");
00114 }
00115 
00116 
00117 
00118 
00120 // Create/Delete Generators
00121 
00122 BOOL  COpenNi2Device::create_Context(char* fname)
00123 {
00124     if (context==NULL) {
00125         context = new openni::Device();
00126         if (context==NULL) {
00127             DEBUG_ERR("COpenNi2Device::create_Context(): context is NULL!!");
00128             return FALSE;
00129         }
00130     }
00131     else context->close();
00132 
00133     const char* uri = fname;
00134     if (uri==NULL) uri = openni::ANY_DEVICE;
00135 
00136     openni::Status ret = context->open(uri);
00137     if (ret!=openni::STATUS_OK) {
00138         DEBUG_ERR("COpenNi2Device::create_Context(): Device Open Error!! (%d)", ret);
00139         deleteNull(context);
00140         return FALSE;
00141     }
00142 
00143     //
00144     //context->setDepthColorSyncEnabled(true);
00145 
00146     DEBUG_INFO("COpenNi2Device::create_Context(): created Context.");
00147     return TRUE;
00148 }
00149 
00150 
00151 
00152 BOOL  COpenNi2Device::create_Recorder(char* fname, BOOL use_image)
00153 {
00154     if (fname==NULL) {
00155         copy_s2Buffer("COpenNi2Device::create_Recorder(): ERROR: File name is NULL.", &m_err_mesg);
00156         return FALSE;
00157     }
00158     if (depth==NULL || (use_image && image==NULL)) {
00159         copy_s2Buffer("COpenNi2Device::create_Recorder(): ERROR: Image or Depth Stream is NULL.", &m_err_mesg);
00160         return FALSE;
00161     }
00162 
00163     if (recorder==NULL) {
00164         recorder = new openni::Recorder();
00165         if (recorder==NULL) {
00166             DEBUG_ERR("COpenNi2Device::create_Recorder(): recorder is NULL!!");
00167             return FALSE;
00168         }
00169     }
00170     else recorder->stop();
00171     
00172     openni::Status ret = recorder->create(fname);
00173     if (ret!=openni::STATUS_OK) {
00174         deleteNull(recorder);
00175         DEBUG_ERR("COpenNi2Device::create_Recorder ERROR: File Open Error.");
00176         copy_s2Buffer("COpenNi2Device::create_Recorder ERROR: File Open Error.", &m_err_mesg);
00177         return FALSE;
00178     }   
00179     
00180     ret = recorder->attach(*depth, true);
00181     if (ret==openni::STATUS_OK && use_image) ret = recorder->attach(*image, true);
00182     if (ret!=openni::STATUS_OK) {
00183         deleteNull(recorder);
00184         DEBUG_ERR("COpenNi2Device::create_Recorder ERROR: Stream Attach Error.");
00185         copy_s2Buffer("COpenNi2Device::create_Recorder ERROR: Stream Attach Error.", &m_err_mesg);
00186         return FALSE;
00187     }
00188 
00189     DEBUG_INFO("COpenNi2Device::create_Recorder(): created Recorder.");
00190     return TRUE;
00191 }
00192 
00193 
00194 
00195 BOOL  COpenNi2Device::create_Image(void)
00196 {
00197     if (!m_has_camera) return FALSE;
00198 
00199     if (context==NULL) {
00200         copy_s2Buffer("COpenNi2Device::create_Image(): ERROR: context is NULL.", &m_err_mesg);
00201         return FALSE;
00202     }
00203 
00204     image = new openni::VideoStream();
00205     if (image==NULL) return FALSE;
00206 
00207     openni::Status ret = image->create(*context, openni::SENSOR_COLOR);
00208     if (ret!=openni::STATUS_OK) {
00209         deleteNull(image);
00210         copy_s2Buffer("COpenNi2Device::create_Image(): ERROR: Craete Error.", &m_err_mesg);
00211         return FALSE;
00212     }
00213 
00214     ret = image->start();
00215     if (ret!=openni::STATUS_OK) {
00216         deleteNull(image);
00217         copy_s2Buffer("COpenNi2Device::create_Image(): ERROR: Start Error.", &m_err_mesg);
00218         return FALSE;
00219     }
00220 
00221     image->setVideoMode(imageMode);
00222 
00223     m_streams[OPENNI2_IMAGE_INDEX] = image;
00224     m_stream_flg |= OPENNI2_IMAGE_FLAG;
00225     m_stream_num++;
00226 
00227     DEBUG_INFO("COpenNi2Device::create_Image(): created Image Stream.");
00228     return TRUE;
00229 }
00230 
00231 
00232 
00233 BOOL  COpenNi2Device::create_Depth(void)
00234 {
00235     if (context==NULL) {
00236         copy_s2Buffer("COpenNi2Device::create_Depth(): ERROR: context is NULL.", &m_err_mesg);
00237         return FALSE;
00238     }
00239 
00240     depth = new openni::VideoStream();
00241     if (depth==NULL) return FALSE;
00242 
00243     openni::Status ret = depth->create(*context, openni::SENSOR_DEPTH);
00244     if (ret!=openni::STATUS_OK) {
00245         deleteNull(depth);
00246         copy_s2Buffer("COpenNi2Device::create_Depth(): ERROR: Craete Error.", &m_err_mesg);
00247         return FALSE;
00248     }
00249 
00250     ret = depth->start();
00251     if (ret!=openni::STATUS_OK) {
00252         deleteNull(depth);
00253         copy_s2Buffer("COpenNi2Device::create_Depth(): ERROR: Start Error.", &m_err_mesg);
00254         return FALSE;
00255     }
00256 
00257     depth->setVideoMode(depthMode);
00258 
00259     m_streams[OPENNI2_DEPTH_INDEX] = depth;
00260     m_stream_flg |= OPENNI2_DEPTH_FLAG;
00261     m_stream_num++;
00262 
00263     DEBUG_INFO("COpenNi2Device::create_Depth(): created Depth Stream.");
00264     return TRUE;
00265 }
00266 
00267 
00268 
00269 BOOL  COpenNi2Device::create_User(void)
00270 {
00271     user = new nite::UserTracker();
00272     if (user==NULL) return FALSE;
00273 
00274     nite::Status ret = user->create(context);   // context==NULL is OK
00275     if (ret!=nite::STATUS_OK) {
00276         deleteNull(user);
00277         copy_s2Buffer("COpenNi2Device::create_Depth(): ERROR: Create Error", &m_err_mesg);
00278         return FALSE;
00279     }
00280 
00281     DEBUG_INFO("COpenNi2Device::create_User(): created User Tracker.");
00282     return TRUE;
00283 }
00284 
00285 
00286 
00287 
00289 // Delete Generators
00290 
00291 void  COpenNi2Device::delete_Context(void)
00292 {
00293     if (context==NULL || !context->isValid()) return;
00294 
00295     //
00296     context->close();
00297     delete(context);
00298     context = NULL;
00299 
00300     return;
00301 }
00302 
00303 
00304 
00305 void    COpenNi2Device::delete_Recorder(void)
00306 {
00307     if (recorder==NULL || !recorder->isValid()) return;
00308 
00309     //
00310     int prev_state = m_state;
00311     m_state = NI_STATE_SAVE_WORKING;
00312     {
00313         recorder->stop();
00314         DEBUG_INFO("COpenNi2Device::delete_Recorder(): Recorder Stopped.");
00315         delete(recorder);
00316         recorder = NULL;
00317     }
00318     m_state = prev_state;
00319 
00320     return;
00321 }
00322 
00323 
00324 
00325 void  COpenNi2Device::delete_Image(void)
00326 {
00327     m_stream_num--;
00328     m_streams[OPENNI2_IMAGE_INDEX] = NULL;
00329     m_stream_flg &= ~OPENNI2_IMAGE_FLAG;
00330 
00331     if (image==NULL || !image->isValid()) return;
00332 
00333     //
00334     image->stop();
00335 
00336     if (imageFrame.isValid()) imageFrame.release();
00337     delete(image);
00338     image = NULL;
00339     return;
00340 }
00341 
00342 
00343 
00344 void  COpenNi2Device::delete_Depth(void)
00345 {
00346     m_stream_num--;
00347     m_streams[OPENNI2_DEPTH_INDEX] = NULL;
00348     m_stream_flg &= ~OPENNI2_DEPTH_FLAG;
00349     
00350     if (depth==NULL || !depth->isValid()) return;
00351 
00352     //
00353     depth->stop();
00354 
00355     if (depthFrame.isValid()) depthFrame.release();
00356     delete(depth);
00357     depth = NULL;
00358     return;
00359 }
00360 
00361 
00362 
00363 void  COpenNi2Device::delete_User(void)
00364 {
00365     if (user==NULL || !user->isValid()) return;
00366 
00367     //
00368     if (userFrame.isValid()) userFrame.release();
00369     delete(user);
00370     user = NULL;
00371 
00372     return;
00373 }
00374 
00375 
00376 
00377 
00379 // File
00380 
00381 BOOL  COpenNi2Device::start_Recorde(char* file_name, BOOL use_image)
00382 {
00383     DEBUG_INFO("COpenNi2Device::delete_Recorder(): Recorder Starting ...");
00384 
00385     BOOL ret = FALSE;
00386     unlink(file_name);
00387     
00388     int prev_state = m_state;
00389     m_state = NI_STATE_SAVE_WORKING;
00390     {
00391         Sleep(NI_WORKING_WAIT_TIME);
00392         ret = create_Recorder(file_name, use_image);
00393         if (ret) {
00394             openni::Status nc = recorder->start();
00395             if (nc!=openni::STATUS_OK) {
00396                 copy_s2Buffer("COpenNi2Device::start_Recorde ERROR: Start Error.", &m_err_mesg);
00397                 ret = FALSE;
00398             }
00399         }
00400     }
00401     m_state = prev_state;
00402 
00403     if (ret) {
00404         DEBUG_INFO("COpenNi2Device::delete_Recorder(): Recorder Started.");
00405     }
00406     else {
00407         delete_Recorder();
00408         unlink(file_name);
00409         DEBUG_INFO("COpenNi2Device::delete_Recorder(): Recorder can not Start.");
00410     }
00411     
00412     return ret;
00413 }
00414 
00415 
00416 
00417 void  COpenNi2Device::stop_Recorde(void)
00418 {
00419     DEBUG_INFO("COpenNi2Device::delete_Recorder(): Recorder Stopping ...");
00420     if (recorder!=NULL && recorder->isValid()) {
00421         delete_Recorder();
00422     }
00423 }
00424 
00425 
00426 
00427 
00429 //
00430 
00431 BOOL  COpenNi2Device::setup_Tracking(int profile, double smooth)
00432 {
00433     if (user!=NULL) {
00434         nite::Status nc = user->setSkeletonSmoothingFactor(smooth);
00435         if (nc==nite::STATUS_OK) return TRUE;
00436     }
00437 
00438     return FALSE;
00439 }
00440 
00441 
00442 
00443 
00445 // Set Data
00446 
00447 void   COpenNi2Device::wait_StreamData(void) 
00448 {
00449 //  return;
00450 
00451     openni::Status rc;
00452     unsigned char flag = 0x00;
00453     int stream_idx;
00454     
00455     m_has_image_data = FALSE;
00456     m_has_depth_data = FALSE;
00457 //  m_has_audio_data = FALSE;
00458 
00459     Loop {
00460         rc = openni::OpenNI::waitForAnyStream(m_streams, m_stream_num, &stream_idx, 0);
00461         if (rc==openni::STATUS_OK) {
00462             if (stream_idx==OPENNI2_IMAGE_INDEX) {
00463                 if (image!=NULL) {
00464                     image->readFrame(&imageFrame);
00465                     flag |= OPENNI2_IMAGE_FLAG;
00466                     m_has_image_data = TRUE;
00467                 }
00468             }
00469             else if (stream_idx==OPENNI2_DEPTH_INDEX) {
00470                 if (depth!=NULL) {
00471                     depth->readFrame(&depthFrame);
00472                     flag |= OPENNI2_DEPTH_FLAG;
00473                     m_has_depth_data = TRUE;
00474                 }
00475             }
00476             /*
00477             else if (stream_idx==OPENNI2_AUDIO_INDEX) {
00478                 if (audio!=NULL) {
00479                     audio->readFrame(&audioFrame);
00480                     flag |= OPENNI2_AUDIO_FLAG;
00481                     m_has_audio_data = TRUE;
00482                 }
00483             }*/
00484 
00485             if ((flag & m_stream_flg)==m_stream_flg) break;
00486         }
00487     }
00488 }
00489 
00490 
00491 
00492 BOOL  COpenNi2Device::set_ImageData(void) 
00493 {
00494     if (image!=NULL) {
00495 //      image->readFrame(&imageFrame);
00496         if (imageFrame.isValid()) return TRUE;
00497     }
00498     return FALSE;
00499 }
00500 
00501 
00502 
00503 BOOL  COpenNi2Device::set_DepthData(void)
00504 {
00505     if (depth!=NULL) {
00506         //depth->readFrame(&depthFrame);
00507         if (depthFrame.isValid()) return TRUE;      
00508     }
00509     return FALSE;
00510 }
00511 
00512 
00513 
00514 BOOL  COpenNi2Device::set_SceneData(void) 
00515 {
00516     if (user!=NULL) {
00517         user->readFrame(&userFrame);
00518         if (userFrame.isValid()) return TRUE;
00519     }
00520 
00521     return FALSE;
00522 }
00523 
00524 
00525 
00526 
00528 // External Support Functions
00529 //
00530 
00531 // need ./OpenNI2/Drivers/*.dll
00532 //
00533 Buffer  jbxl::initialize_OpenNI2(void)
00534 {
00535     Buffer mesg = init_Buffer();
00536 
00537     openni::Status rc = openni::OpenNI::initialize();
00538     if (rc!=openni::STATUS_OK) {
00539         mesg = make_Buffer(LMESG);
00540         copy_s2Buffer("jbxl::initializeOpenNI2(): ERROR: Initialize OpenNI Error!!\n", &mesg);
00541         cat_s2Buffer (openni::OpenNI::getExtendedError(), &mesg);
00542         DEBUG_WARN("%s", mesg.buf);
00543     }
00544     else DEBUG_INFO("jbxl::initialize_OpenNI2(): initialize OpenNI2");
00545 
00546     return mesg;
00547 }
00548 
00549 
00550 
00551 void  jbxl::shutdown_OpenNI2(void)
00552 { 
00553     openni::OpenNI::shutdown();
00554     DEBUG_INFO("jbxl::shutdown_OpenNI2(): shutdown OpenNI2");
00555 }
00556 
00557 
00558 
00559 //
00560 Buffer  jbxl::initialize_NiTE2(void)
00561 {
00562     Buffer mesg = init_Buffer();
00563     
00564     nite::Status nc = nite::NiTE::initialize();
00565     if (nc!=nite::STATUS_OK) {
00566         mesg = make_Buffer(LMESG);
00567         copy_s2Buffer("jbxl::initializeNiTE2(): ERROR: Initialize NiTE Error!!\n", &mesg);
00568         DEBUG_WARN("%s", mesg.buf);
00569     }
00570     else DEBUG_INFO("jbxl::initialize_NiTE2(): initialize NiTE2");
00571 
00572     return mesg;
00573 }
00574 
00575 
00576 
00577 void  jbxl::shutdown_NiTE2(void)
00578 { 
00579     nite::NiTE::shutdown();
00580     DEBUG_INFO("jbxl::shutdown_NiTE2(): shutdown NiTE2");
00581 }
00582 
00583 
00584 #endif      // ifdef ENABLE_OPENNI2x