Kinect SDK 2.0 ручка и получить глубину кадра

Question

Я фактически работаю с Kinect V2 (один для Xbox One), и я пытаюсь иметь поток глубины. Я хочу посмотреть, что видит датчик глубины Kinect. Но мне не удается открыть поток. Мне удается открыть только один кадр с другим фрагментом кода, но не видео. С некоторыми исследованиями я попытался использовать дескрипторы, но код, который я написал, не печатает на экране строку «поток», помещенную в конец кода. Я работаю над VS2012, код находится на C++.

Я думаю, что у меня есть это, потому что я не знаю, как использовать исправление дескриптора ... Если кто-нибудь может мне помочь и объяснить мне, что такое дескриптор вместо какого-то указателя на что-то, было бы здорово , Спасибо

Вот мой код:

HRESULT hr=S_OK; WAITABLE_HANDLE *stream=nullptr; IKinectSensor* kinectSensor=nullptr;

if(SUCCEEDED(hr)) 
{ 
    std::cout << "Success IKinectSensor::GetDefaultSensor" << std::endl; 
} 

else 
{ 
    std::cout << "Failed IKinectSensor::GetDefaultSensor" << std::endl; 
} 

std::cout << "Opening sensors" << std::endl; 
if(kinectSensor != NULL) 
{ 
    hr = kinectSensor->Open(); 

    Sleep(sleeptime*5); 
    if(SUCCEEDED(hr)) 
    { 
     std::cout << "Success IKinectSensor::Open" << std::endl; 
    } 

    else 
    { 
     std::cout << "Failed IKinectSensor::Open" << std::endl; 
    } 
} 

}

hr = kinectSensor->OpenMultiSourceFrameReader(FrameSourceTypes_Depth | FrameSourceTypes_Color , &multiSourceReader); 
if(SUCCEEDED(hr)) 
{ 
    std::cout << "reader open" << std::endl; 

    hr = multiSourceReader->SubscribeMultiSourceFrameArrived(stream); 
    if(SUCCEEDED(hr)) 
    { 
     std::cout << "stream" << std::endl; 
    } 
} 

Answer 1

Я не использовал ручку. См. Приведенный ниже фрагмент кода для получения каротажа глубины из многоканального считывателя кадров и отображения его с помощью OpenCV.

#include <Kinect.h> 
#include <opencv2/core.hpp> 
#include <opencv2/highgui.hpp> 

// helper function 
template <class Interface> inline void safe_release(Interface **ppT) 
{ 
    if (*ppT) 
    { 
     (*ppT)->Release(); 
     *ppT = NULL; 
    } 
} 

bool setup_kinect_sensor_and_acquire_frame() 
{ 
    IKinectSensor* kinect_sensor 

    // initialize kinect sensor 
    HRESULT hr = GetDefaultKinectSensor(&kinect_sensor); 
    if (FAILED(hr) || !kinect_sensor) 
    { 
     safe_release(&p_multisource_frame); 
     return false; 
    } 

    kinect_sensor->Open(); 
    if (FAILED(hr)) 
    { 
     return false; 
    } 

    // initialize kinect multisource frame reader 
    IMultiSourceFrameReader* kinect_multisource_reader; 
    hr = kinect_sensor->OpenMultiSourceFrameReader(FrameSourceTypes_Depth, &kinect_multisource_reader;); 
    if (FAILED(hr)) 
    { 
     safe_release(&kinect_multisource_reader); 
     return false; 
    } 

    // acquire multisource frame 
    IMultiSourceFrame* p_multisource_frame = NULL; 
    HRESULT hr = kinect_multisource_reader->AcquireLatestFrame(&p_multisource_frame); 
    if (FAILED(hr)) 
    { 
     safe_release(&p_multisource_frame); 
     return false; 
    } 

    // get depth frame 
    IDepthFrameReference* p_depth_frame_ref = NULL; 
    hr = p_multisource_frame->get_DepthFrameReference(&p_depth_frame_ref); 
    if (FAILED(hr)) 
    { 
     safe_release(&p_depth_frame_ref); 
     return false; 
    } 

    IDepthFrame* p_depth_frame = NULL; 
    IFrameDescription* p_frame_description = NULL; 
    int width = 0; 
    int height = 0; 
    unsigned short depth_min_distance = 0; 
    unsigned short depth_max_distance = 0; 
    unsigned short* p_depth_buffer = NULL; 

    hr = p_depth_frame_ref->AcquireFrame(&p_depth_frame); 
    if (SUCCEEDED(hr)) 
    { 
     hr = p_depth_frame->get_FrameDescription(&p_frame_description); 
    } 
    if (SUCCEEDED(hr)) 
    { 
     hr = p_frame_description->get_Width(&width); 
    } 
    if (SUCCEEDED(hr)) 
    { 
     hr = p_frame_description->get_Height(&height); 
    } 
    if (width != 512 || height != 424) 
    { 
     safe_release(&p_depth_frame); 
     safe_release(&p_frame_description); 
     return false; 
    } 

    // process depth frame 
    if (SUCCEEDED(hr)) 
    { 
     hr = p_depth_frame->get_DepthMinReliableDistance(&depth_min_distance); 
    } 
    if (SUCCEEDED(hr)) 
    { 
     hr = p_depth_frame->get_DepthMaxReliableDistance(&depth_max_distance); 
    } 
    if (SUCCEEDED(hr)) 
    { 
     int size = 512 * 424; 
     p_depth_buffer = new unsigned short[size]; 
     hr = p_depth_frame->CopyFrameDataToArray(size, p_depth_buffer); 
     if (SUCCEEDED(hr)) 
     { 
      cv::Mat depth_map(cv::Size(DEPTH_WIDTH, DEPTH_HEIGHT), CV_16UC1, p_depth_buffer); 
      double scale = 255.0/(depth_max_distance - depth_min_distance); 
      depth_map.convertTo(depth_frame, CV_8UC1, scale); 
      cv::imshow("depth", depth_map); 
     } 
    } 

    // Clean up depth frame 
    safe_release(&p_depth_frame_ref); 
    safe_release(&p_depth_frame); 
    safe_release(&p_frame_description); 
    if (p_depth_buffer != NULL) { 
     delete[] p_depth_buffer; 
     p_depth_buffer = NULL; 
    } 
    if (FAILED(hr)) 
    { 
     return false; 
    } 
    else 
    { 
     return true; 
    } 
}