///Supply the event initialization function to the base class. HRESULT KinectSkeletalSubSys::subsystemInit(INuiSensor* kSensor) { sensor = kSensor; HRESULT hr; //Skeletal Stream //if(m_skeletalStreamEnabled){ m_hNextSkeletonEvent = CreateEvent( NULL, TRUE, FALSE, NULL ); //Skeleton Engine Initialization if ( HasSkeletalEngine( sensor ) ){ //initialize Skeleton Tracking hr = sensor->NuiSkeletonTrackingEnable( m_hNextSkeletonEvent, 0 ); //TODO: Check settings work when near mode is switched //hr = m_pNuiSensor->NuiSkeletonTrackingEnable( // m_hNextSkeletonEvent, // NUI_SKELETON_TRACKING_FLAG_ENABLE_IN_NEAR_RANGE | // NUI_SKELETON_TRACKING_FLAG_ENABLE_SEATED_SUPPORT // ); } //++m_activeNumOfStreams; //} return hr; }
RGBQUAD Nui_ShortToQuad_Depth( USHORT s ) { bool hasPlayerData = HasSkeletalEngine(m_pNuiInstance); USHORT RealDepth = hasPlayerData ? (s & 0xfff8) >> 3 : s & 0xffff; USHORT Player = hasPlayerData ? s & 7 : 0; // transform 13-bit depth information into an 8-bit intensity appropriate // for display (we disregard information in most significant bit) BYTE l = 255 - (BYTE)(256*RealDepth/0x0fff); RGBQUAD q; q.rgbRed = q.rgbBlue = q.rgbGreen = 0; switch( Player ) { case 0: q.rgbRed = l / 2; q.rgbBlue = l / 2; q.rgbGreen = l / 2; break; case 1: q.rgbRed = l; break; case 2: q.rgbGreen = l; break; case 3: q.rgbRed = l / 4; q.rgbGreen = l; q.rgbBlue = l; break; case 4: q.rgbRed = l; q.rgbGreen = l; q.rgbBlue = l / 4; break; case 5: q.rgbRed = l; q.rgbGreen = l / 4; q.rgbBlue = l; break; case 6: q.rgbRed = l / 2; q.rgbGreen = l / 2; q.rgbBlue = l; break; case 7: q.rgbRed = 255 - ( l / 2 ); q.rgbGreen = 255 - ( l / 2 ); q.rgbBlue = 255 - ( l / 2 ); } return q; }
bool Kinect::openDepthStream() { if ( mSensor != 0) { long hr = mSensor->NuiImageStreamOpen( mDeviceOptions.getDepthResolution() != ImageResolution::NUI_IMAGE_RESOLUTION_640x480 && HasSkeletalEngine( mSensor ) ? NUI_IMAGE_TYPE_DEPTH_AND_PLAYER_INDEX : NUI_IMAGE_TYPE_DEPTH, mDeviceOptions.getDepthResolution(), 0, 2, 0, &mDepthStreamHandle );; if ( FAILED( hr ) ) { trace( "Unable to open depth image stream: " ); error( hr ); stop(); return false; } } return true; }
long Device::openDepthStream() { if ( mSensor != 0) { NUI_IMAGE_TYPE type = mDeviceOptions.getDepthResolution() != ImageResolution::NUI_IMAGE_RESOLUTION_640x480 && HasSkeletalEngine( mSensor ) ? NUI_IMAGE_TYPE_DEPTH_AND_PLAYER_INDEX : NUI_IMAGE_TYPE_DEPTH; long hr = mSensor->NuiImageStreamOpen( type, mDeviceOptions.getDepthResolution(), mDeviceOptions.isNearModeEnabled() ? NUI_IMAGE_STREAM_FLAG_ENABLE_NEAR_MODE : 0, 2, mDepthEvent, &mDepthStreamHandle ); if ( FAILED( hr ) ) { console() << "Unable to open depth image stream: " << endl; error( hr ); stop(); return hr; } } return S_OK; }
/// <summary> /// Open stream with a certain image resolution. /// </summary> /// <param name="resolution">Frame image resolution</param> /// <returns>Indicates success or failure.</returns> HRESULT NuiDepthStream::OpenStream(NUI_IMAGE_RESOLUTION resolution) { m_imageType = HasSkeletalEngine(m_pNuiSensor) ? NUI_IMAGE_TYPE_DEPTH_AND_PLAYER_INDEX : NUI_IMAGE_TYPE_DEPTH; // Open depth stream HRESULT hr = m_pNuiSensor->NuiImageStreamOpen(m_imageType, resolution, 0, 2, GetFrameReadyEvent(), &m_hStreamHandle); if (SUCCEEDED(hr)) { m_pNuiSensor->NuiImageStreamSetImageFrameFlags(m_hStreamHandle, m_nearMode ? NUI_IMAGE_STREAM_FLAG_ENABLE_NEAR_MODE : 0); // Set image flags m_imageBuffer.SetImageSize(resolution); // Set source image resolution to image buffer } return hr; }
void KinectImpl::close(void) { CloseHandle( hNextColorFrameEvent ); hNextColorFrameEvent = NULL; CloseHandle( hNextDepthFrameEvent ); hNextDepthFrameEvent = NULL; CloseHandle( hNextSkeletonEvent ); hNextSkeletonEvent = NULL; if(HasSkeletalEngine(pNuiSensor)) pNuiSensor->NuiSkeletonTrackingDisable(); #if defined(USE_KINECT_FACETRACKER) clearFaceTracker(); #endif pNuiSensor->NuiShutdown(); pNuiSensor->Release(); pNuiSensor = NULL; }
/// <summary> /// Start stream processing /// </summary> HRESULT NuiSkeletonStream::StartStream() { if (HasSkeletalEngine(m_pNuiSensor)) { if (m_paused) { // Clear skeleton data in stream viewers AssignSkeletonFrameToStreamViewers(nullptr); // Disable tracking skeleton return m_pNuiSensor->NuiSkeletonTrackingDisable(); } else { // Enable tracking skeleton DWORD flags = (m_seated ? NUI_SKELETON_TRACKING_FLAG_ENABLE_SEATED_SUPPORT : 0) | (m_near ? NUI_SKELETON_TRACKING_FLAG_ENABLE_IN_NEAR_RANGE : 0) | (ChooserModeDefault != m_chooserMode ? NUI_SKELETON_TRACKING_FLAG_TITLE_SETS_TRACKED_SKELETONS : 0); return m_pNuiSensor->NuiSkeletonTrackingEnable(GetFrameReadyEvent(), flags); } } return E_FAIL; }
/// <summary> /// Open stream with a certain image resolution. /// </summary> /// <param name="resolution">Frame image resolution</param> /// <returns>Indicates success or failure.</returns> HRESULT NuiDepthStream::OpenStream(NUI_IMAGE_RESOLUTION resolution) { m_imageType = HasSkeletalEngine(m_pNuiSensor) ? NUI_IMAGE_TYPE_DEPTH_AND_PLAYER_INDEX : NUI_IMAGE_TYPE_DEPTH; // Open depth stream HRESULT hr = m_pNuiSensor->NuiImageStreamOpen(m_imageType, resolution, 0, 2, GetFrameReadyEvent(), &m_hStreamHandle); if (SUCCEEDED(hr)) { m_pNuiSensor->NuiImageStreamSetImageFrameFlags(m_hStreamHandle, m_nearMode ? NUI_IMAGE_STREAM_FLAG_ENABLE_NEAR_MODE : 0); // Set image flags m_imageBuffer.SetImageSize(resolution); // Set source image resolution to image buffer } //////////////Video writer m_ImageRes=cvSize(static_cast<int>(m_imageBuffer.GetWidth()),static_cast<int>(m_imageBuffer.GetHeight())); m_pcolorImage =cvCreateImage(m_ImageRes, 8, 1); //openCV only supports <=8 bits return hr; }
/* * @brief Any User DeInitialization Goes Here */ void close(void) { for(int i=0;i<TEXTURE_NUM;i++){ glDeleteTextures(1, &bg_texture[i]); } CloseHandle( hNextColorFrameEvent ); hNextColorFrameEvent = NULL; CloseHandle( hNextDepthFrameEvent ); hNextDepthFrameEvent = NULL; CloseHandle( hNextSkeletonEvent ); hNextSkeletonEvent = NULL; if(HasSkeletalEngine(pNuiSensor)) pNuiSensor->NuiSkeletonTrackingDisable(); #if defined(USE_FACETRACKER) clearFaceTracker(); #endif pNuiSensor->NuiShutdown(); pNuiSensor->Release(); pNuiSensor = NULL; }
/* * @brief A general Nui initialization function. Sets all of the initial parameters. */ void initNui(void) // We call this right after Nui functions called. { HRESULT hr; hr = NuiCreateSensorByIndex(0, &pNuiSensor); if(FAILED(hr)) STDERR("Cannot connect with kinect0.\r\n"); hr = pNuiSensor->NuiInitialize( //NUI_INITIALIZE_FLAG_USES_DEPTH | NUI_INITIALIZE_FLAG_USES_DEPTH_AND_PLAYER_INDEX | NUI_INITIALIZE_FLAG_USES_COLOR | NUI_INITIALIZE_FLAG_USES_SKELETON ); if ( E_NUI_SKELETAL_ENGINE_BUSY == hr ){ hr = pNuiSensor->NuiInitialize( NUI_INITIALIZE_FLAG_USES_DEPTH | NUI_INITIALIZE_FLAG_USES_COLOR ); } if(FAILED(hr)){ STDERR("Cannot initialize kinect.\r\n"); } hNextColorFrameEvent = CreateEvent( NULL, TRUE, FALSE, NULL ); hNextDepthFrameEvent = CreateEvent( NULL, TRUE, FALSE, NULL ); hNextSkeletonEvent = CreateEvent( NULL, TRUE, FALSE, NULL ); if(HasSkeletalEngine(pNuiSensor)){ hr = pNuiSensor->NuiSkeletonTrackingEnable( hNextSkeletonEvent, //NUI_SKELETON_TRACKING_FLAG_TITLE_SETS_TRACKED_SKELETONS | //NUI_SKELETON_TRACKING_FLAG_ENABLE_SEATED_SUPPORT 0 ); if(FAILED(hr)) STDERR("Cannot track skeletons\r\n"); } hr = pNuiSensor->NuiImageStreamOpen( NUI_IMAGE_TYPE_COLOR, NUI_IMAGE_RESOLUTION_640x480, 0, 2, hNextColorFrameEvent, &pVideoStreamHandle ); if(FAILED(hr)){ STDERR("Cannot open image stream\r\n"); } hr = pNuiSensor->NuiImageStreamOpen( HasSkeletalEngine(pNuiSensor) ? NUI_IMAGE_TYPE_DEPTH_AND_PLAYER_INDEX : NUI_IMAGE_TYPE_DEPTH, NUI_IMAGE_RESOLUTION_320x240, 0, 2, hNextDepthFrameEvent, &pDepthStreamHandle ); if(FAILED(hr)){ STDERR("Cannot open depth and player stream\r\n"); } /* hr = pNuiSensor->NuiImageStreamOpen( NUI_IMAGE_TYPE_DEPTH, NUI_IMAGE_RESOLUTION_640x480, 0, 2, hNextDepthFrameEvent, &pDepthStreamHandle ); if(FAILED(hr)){ STDERR("Cannot open depth stream\r\n"); } */ #if defined(USE_FACETRACKER) initFaceTracker(); #endif }
HRESULT Nui_Init() { HRESULT hr; RECT rc; if (!m_pNuiInstance) { HRESULT hr = MSR_NuiCreateInstanceByIndex(0, &m_pNuiInstance); if (FAILED(hr)) { return hr; } if (m_instanceId) { ::SysFreeString(m_instanceId); } m_instanceId = m_pNuiInstance->NuiInstanceName(); } m_hNextDepthFrameEvent = CreateEvent( NULL, TRUE, FALSE, NULL ); m_hNextVideoFrameEvent = CreateEvent( NULL, TRUE, FALSE, NULL ); m_hNextSkeletonEvent = CreateEvent( NULL, TRUE, FALSE, NULL ); DWORD nuiFlags = NUI_INITIALIZE_FLAG_USES_DEPTH_AND_PLAYER_INDEX | NUI_INITIALIZE_FLAG_USES_SKELETON | NUI_INITIALIZE_FLAG_USES_COLOR; hr = m_pNuiInstance->NuiInitialize(nuiFlags); if (E_NUI_SKELETAL_ENGINE_BUSY == hr) { nuiFlags = NUI_INITIALIZE_FLAG_USES_DEPTH | NUI_INITIALIZE_FLAG_USES_COLOR; hr = m_pNuiInstance->NuiInitialize(nuiFlags); } if( FAILED( hr ) ) { fprintf(stderr,"Failed on initialization!\n"); return hr; } if (HasSkeletalEngine(m_pNuiInstance)) { hr = m_pNuiInstance->NuiSkeletonTrackingEnable( m_hNextSkeletonEvent, 0 ); if( FAILED( hr ) ) { fprintf(stderr,"Skeleton Tracking is disable!\n"); return hr; } } hr = m_pNuiInstance->NuiImageStreamOpen( NUI_IMAGE_TYPE_COLOR, NUI_IMAGE_RESOLUTION_640x480, 0, 2, m_hNextVideoFrameEvent, &m_pVideoStreamHandle ); if( FAILED( hr ) ) { fprintf(stderr,"Failed on opening color stream!\n"); return hr; } hr = m_pNuiInstance->NuiImageStreamOpen( HasSkeletalEngine(m_pNuiInstance) ? NUI_IMAGE_TYPE_DEPTH_AND_PLAYER_INDEX : NUI_IMAGE_TYPE_DEPTH, NUI_IMAGE_RESOLUTION_320x240, 0, 2, m_hNextDepthFrameEvent, &m_pDepthStreamHandle ); if( FAILED( hr ) ) { fprintf(stderr,"Failed on opening depth stream!\n"); return hr; } // Create Image //cvNamedWindow("Kinect depth image",CV_WINDOW_AUTOSIZE); //cvNamedWindow("Kinect color image",CV_WINDOW_AUTOSIZE); //cvNamedWindow("Kinect skeleton image",CV_WINDOW_AUTOSIZE); kinect_color_image = cvCreateImage(cvSize(640,480),IPL_DEPTH_8U,3); kinect_depth_image = cvCreateImage(cvSize(320,240),IPL_DEPTH_8U,3); kinect_skeleton_image = cvCreateImage(cvSize(320,240),IPL_DEPTH_8U,3); // Start the Nui processing thread m_hEvNuiProcessStop=CreateEvent(NULL,FALSE,FALSE,NULL); m_hThNuiProcess=CreateThread(NULL,0,Nui_ProcessThread,NULL,0,0); return hr; }
bool KinectHandler::initialize( int kid ) { HRESULT hr = NuiCreateSensorByIndex( 0, &_context ); if ( FAILED(hr) ) { OSG_WARN << "Failed to connect to Kinect device." << std::endl; return false; } DWORD nuiFlags = NUI_INITIALIZE_FLAG_USES_DEPTH_AND_PLAYER_INDEX | NUI_INITIALIZE_FLAG_USES_SKELETON | NUI_INITIALIZE_FLAG_USES_COLOR | NUI_INITIALIZE_FLAG_USES_DEPTH; hr = _context->NuiInitialize( nuiFlags ); if ( FAILED(hr) ) { switch ( hr ) { case E_NUI_DEVICE_IN_USE: OSG_WARN << "Kinect device is already in use." << std::endl; break; case E_NUI_SKELETAL_ENGINE_BUSY: OSG_WARN << "Kinect device is busy at present." << std::endl; break; default: OSG_WARN << "Kinect device failed with error code " << std::hex << (long)hr << std::dec << std::endl; break; } return false; } bool hasSkeleton = HasSkeletalEngine(_context); if ( hasSkeleton ) { _nextSkeletonEvent = CreateEvent( NULL, TRUE, FALSE, NULL ); hr = _context->NuiSkeletonTrackingEnable( _nextSkeletonEvent, 0 ); if ( FAILED(hr) ) { OSG_WARN << "Unable to start tracking skeleton." << std::endl; return false; } _nuiProcessStopEvent = CreateEvent( NULL, FALSE, FALSE, NULL ); _nuiProcess = CreateThread( NULL, 0, nuiProcessThread, this, 0, NULL ); } else { OSG_WARN << "Current device don't have a skeleton engine." << std::endl; } _nextImageFrameEvent = CreateEvent( NULL, TRUE, FALSE, NULL ); /*if ( hasSkeleton ) { hr = _context->NuiImageStreamOpen( NUI_IMAGE_TYPE_DEPTH_AND_PLAYER_INDEX, KINECT_IMAGE_RESOLUTION, 0, 2, _nextImageFrameEvent, &_videoStreamHandle ); } else*/ { hr = _context->NuiImageStreamOpen( NUI_IMAGE_TYPE_DEPTH, KINECT_IMAGE_RESOLUTION, 0, 2, _nextImageFrameEvent, &_videoStreamHandle ); } //hr = _context->NuiImageStreamOpen( NUI_IMAGE_TYPE_COLOR, KINECT_IMAGE_RESOLUTION, // 0, 2, _nextImageFrameEvent, &_videoStreamHandle ); if ( FAILED(hr) ) { OSG_WARN << "Unable to create image stream. Error code " << std::hex << (long)hr << std::dec << std::endl; return false; } return true; }
HRESULT Nui_Init( ) { HRESULT hr; bool result; if ( !m_pNuiSensor ) { hr = NuiCreateSensorByIndex(0, &m_pNuiSensor); if ( FAILED(hr) ) { return hr; } SysFreeString(m_instanceId); m_instanceId = m_pNuiSensor->NuiDeviceConnectionId(); } m_hNextDepthFrameEvent = CreateEvent( NULL, TRUE, FALSE, NULL ); m_hNextColorFrameEvent = CreateEvent( NULL, TRUE, FALSE, NULL ); m_hNextSkeletonEvent = CreateEvent( NULL, TRUE, FALSE, NULL ); DWORD nuiFlags = NUI_INITIALIZE_FLAG_USES_DEPTH_AND_PLAYER_INDEX | NUI_INITIALIZE_FLAG_USES_SKELETON | NUI_INITIALIZE_FLAG_USES_COLOR; hr = m_pNuiSensor->NuiInitialize(nuiFlags); if ( E_NUI_SKELETAL_ENGINE_BUSY == hr ) { nuiFlags = NUI_INITIALIZE_FLAG_USES_DEPTH | NUI_INITIALIZE_FLAG_USES_COLOR; hr = m_pNuiSensor->NuiInitialize( nuiFlags) ; } if ( HasSkeletalEngine( m_pNuiSensor ) ) { //m_SkeletonTrackingFlags = NUI_SKELETON_TRACKING_FLAG_TITLE_SETS_TRACKED_SKELETONS; hr = m_pNuiSensor->NuiSkeletonTrackingEnable( m_hNextSkeletonEvent, 0/*m_SkeletonTrackingFlags*/ ); if( FAILED( hr ) ) { return hr; } } g_ColorImgResolution = NUI_IMAGE_RESOLUTION_640x480; hr = m_pNuiSensor->NuiImageStreamOpen( NUI_IMAGE_TYPE_COLOR, g_ColorImgResolution, 0, 2, m_hNextColorFrameEvent, &m_pVideoStreamHandle ); if ( FAILED( hr ) ) { return hr; } //g_DepthImgResolution = NUI_IMAGE_RESOLUTION_320x240; g_DepthImgResolution = NUI_IMAGE_RESOLUTION_640x480; hr = m_pNuiSensor->NuiImageStreamOpen( HasSkeletalEngine(m_pNuiSensor) ? NUI_IMAGE_TYPE_DEPTH_AND_PLAYER_INDEX : NUI_IMAGE_TYPE_DEPTH, g_DepthImgResolution, m_DepthStreamFlags, 2, m_hNextDepthFrameEvent, &m_pDepthStreamHandle ); if ( FAILED( hr ) ) { return hr; } //new点云数据 NuiImageResolutionToSize(g_DepthImgResolution, g_DepthWidth, g_DepthHeight ); g_PointsData = new Vector4[g_DepthWidth*g_DepthHeight]; m_DepthData = new USHORT[g_DepthWidth*g_DepthHeight]; //new图像数据 NuiImageResolutionToSize(g_ColorImgResolution, g_ColorWidth, g_ColorHeight); g_ColorsData = new BYTE[g_ColorWidth*g_ColorHeight*4]; g_ColorCoordinates = new LONG[g_DepthWidth*g_DepthHeight*2]; g_colorToDepthDivisor = g_ColorWidth/g_DepthWidth; // Start the Nui processing thread m_hEvNuiProcessStop = CreateEvent( NULL, FALSE, FALSE, NULL ); m_hThNuiProcess = CreateThread( NULL, 0, Nui_ProcessThread, NULL, 0, NULL ); g_TrackingUserID= 0; return hr; }
HRESULT CSkeletalViewerApp::Nui_Init() { HRESULT hr; RECT rc; if (!m_pNuiInstance) { HRESULT hr = MSR_NuiCreateInstanceByIndex(0, &m_pNuiInstance); if (FAILED(hr)) { return hr; } if (m_instanceId) { ::SysFreeString(m_instanceId); } m_instanceId = m_pNuiInstance->NuiInstanceName(); } m_hNextDepthFrameEvent = CreateEvent( NULL, TRUE, FALSE, NULL ); m_hNextVideoFrameEvent = CreateEvent( NULL, TRUE, FALSE, NULL ); m_hNextSkeletonEvent = CreateEvent( NULL, TRUE, FALSE, NULL ); GetWindowRect(GetDlgItem( m_hWnd, IDC_SKELETALVIEW ), &rc ); int width = rc.right - rc.left; int height = rc.bottom - rc.top; HDC hdc = GetDC(GetDlgItem( m_hWnd, IDC_SKELETALVIEW)); m_SkeletonBMP = CreateCompatibleBitmap( hdc, width, height ); m_SkeletonDC = CreateCompatibleDC( hdc ); ::ReleaseDC(GetDlgItem(m_hWnd,IDC_SKELETALVIEW), hdc ); m_SkeletonOldObj = SelectObject( m_SkeletonDC, m_SkeletonBMP ); hr = m_DrawDepth.CreateDevice( GetDlgItem( m_hWnd, IDC_DEPTHVIEWER ) ); if( FAILED( hr ) ) { MessageBoxResource( m_hWnd,IDS_ERROR_D3DCREATE,MB_OK | MB_ICONHAND); return hr; } hr = m_DrawDepth.SetVideoType( 320, 240, 320 * 4 ); if( FAILED( hr ) ) { MessageBoxResource( m_hWnd,IDS_ERROR_D3DVIDEOTYPE,MB_OK | MB_ICONHAND); return hr; } hr = m_DrawVideo.CreateDevice( GetDlgItem( m_hWnd, IDC_VIDEOVIEW ) ); if( FAILED( hr ) ) { MessageBoxResource( m_hWnd,IDS_ERROR_D3DCREATE,MB_OK | MB_ICONHAND); return hr; } hr = m_DrawVideo.SetVideoType( 640, 480, 640 * 4 ); if( FAILED( hr ) ) { MessageBoxResource( m_hWnd,IDS_ERROR_D3DVIDEOTYPE,MB_OK | MB_ICONHAND); return hr; } DWORD nuiFlags = NUI_INITIALIZE_FLAG_USES_DEPTH_AND_PLAYER_INDEX | NUI_INITIALIZE_FLAG_USES_SKELETON | NUI_INITIALIZE_FLAG_USES_COLOR; hr = m_pNuiInstance->NuiInitialize(nuiFlags); if (E_NUI_SKELETAL_ENGINE_BUSY == hr) { nuiFlags = NUI_INITIALIZE_FLAG_USES_DEPTH | NUI_INITIALIZE_FLAG_USES_COLOR; hr = m_pNuiInstance->NuiInitialize(nuiFlags); } if( FAILED( hr ) ) { MessageBoxResource(m_hWnd,IDS_ERROR_NUIINIT,MB_OK | MB_ICONHAND); return hr; } if (HasSkeletalEngine(m_pNuiInstance)) { hr = m_pNuiInstance->NuiSkeletonTrackingEnable( m_hNextSkeletonEvent, 0 ); if( FAILED( hr ) ) { MessageBoxResource(m_hWnd,IDS_ERROR_SKELETONTRACKING,MB_OK | MB_ICONHAND); return hr; } } hr = m_pNuiInstance->NuiImageStreamOpen( NUI_IMAGE_TYPE_COLOR, NUI_IMAGE_RESOLUTION_640x480, 0, 2, m_hNextVideoFrameEvent, &m_pVideoStreamHandle ); if( FAILED( hr ) ) { MessageBoxResource(m_hWnd,IDS_ERROR_VIDEOSTREAM,MB_OK | MB_ICONHAND); return hr; } hr = m_pNuiInstance->NuiImageStreamOpen( HasSkeletalEngine(m_pNuiInstance) ? NUI_IMAGE_TYPE_DEPTH_AND_PLAYER_INDEX : NUI_IMAGE_TYPE_DEPTH, NUI_IMAGE_RESOLUTION_320x240, 0, 2, m_hNextDepthFrameEvent, &m_pDepthStreamHandle ); if( FAILED( hr ) ) { MessageBoxResource(m_hWnd,IDS_ERROR_DEPTHSTREAM,MB_OK | MB_ICONHAND); return hr; } // Start the Nui processing thread m_hEvNuiProcessStop=CreateEvent(NULL,FALSE,FALSE,NULL); m_hThNuiProcess=CreateThread(NULL,0,Nui_ProcessThread,this,0,NULL); return hr; }
// TODO: allow for customizing which streams are initialized HRESULT SimpleKinect::Initialize() { INuiSensor * pNuiSensor; HRESULT hr; int iSensorCount = 0; hr = NuiGetSensorCount(&iSensorCount); if (FAILED(hr)) { return hr; } // Find the correct sensor cout << "SimpleKinect: Finding sensor..." << endl; for (int i = 0; i < iSensorCount; ++i) { // Create the sensor so we can check status, if we can't create it, move on to the next hr = NuiCreateSensorByIndex(i, &pNuiSensor); if (FAILED(hr)) { continue; } // Get the status of the sensor, and if connected, then we can initialize it hr = pNuiSensor->NuiStatus(); if (S_OK == hr) { m_pNuiSensor = pNuiSensor; break; } // This sensor wasn't OK, so release it since we're not using it pNuiSensor->Release(); } // Open depth stream if (NULL != m_pNuiSensor) { cout << "SimpleKinect: Opening depth stream.." << endl; // Initialize the Kinect and specify that we'll be using depth, player index and color hr = m_pNuiSensor->NuiInitialize(NUI_INITIALIZE_FLAG_USES_DEPTH_AND_PLAYER_INDEX | NUI_INITIALIZE_FLAG_USES_COLOR | NUI_INITIALIZE_FLAG_USES_SKELETON ); if (SUCCEEDED(hr)) { // Open a depth image stream to receive depth frames hr = m_pNuiSensor->NuiImageStreamOpen( NUI_IMAGE_TYPE_DEPTH_AND_PLAYER_INDEX, NUI_IMAGE_RESOLUTION_640x480, 0, 2, NULL, &m_pDepthStreamHandle); } else { cerr << "SimpleKinect: Failed to open depth and player stream!" << endl; return E_FAIL; } // open color stream cout << "SimpleKinect: Opening color stream.." << endl; hr = m_pNuiSensor->NuiImageStreamOpen( NUI_IMAGE_TYPE_COLOR, NUI_IMAGE_RESOLUTION_640x480, 0, 2, NULL, &m_pColorStreamHandle); if(!SUCCEEDED(hr)) { cerr << "SimpleKinect: Failed to open color stream!" << endl; return E_FAIL; } cout << "SimpleKinect: Opening skeleton stream.." << endl; // open skeleton stream if(HasSkeletalEngine(m_pNuiSensor)) { hr = m_pNuiSensor->NuiSkeletonTrackingEnable(NULL, NUI_SKELETON_TRACKING_FLAG_ENABLE_IN_NEAR_RANGE | NUI_SKELETON_TRACKING_FLAG_ENABLE_SEATED_SUPPORT | NUI_SKELETON_TRACKING_FLAG_SUPPRESS_NO_FRAME_DATA); if(!SUCCEEDED(hr)) { cerr << "SimpleKinect: Failed to open skeleton stream!" << endl; return E_FAIL; } } else { cerr << "SimpleKinect: Sensor does not have skeletal engine!" << endl; } } if (NULL == m_pNuiSensor || FAILED(hr)) { cerr << "SimpleKinect: No ready Kinect found!" << endl; return E_FAIL; } else { BSTR uniqueId = m_pNuiSensor->NuiUniqueId(); cout << "SimpleKinect Connected to sensor " << uniqueId << endl; } m_isInitialized = true; return hr; }
HRESULT Kinect::initialize() { HRESULT hr; bool result; //prepare the cwnd cWnd.m_hWnd = hWnd; //init Direct2D D2D1CreateFactory(D2D1_FACTORY_TYPE_MULTI_THREADED, &d2DFactory); //init faceTracker faceTracker = new FaceTracking(hWnd, d2DFactory, cWnd); //the three events that the kinect will throw nextDepthFrameEvent = CreateEvent( NULL, TRUE, FALSE, NULL ); nextColorFrameEvent = CreateEvent( NULL, TRUE, FALSE, NULL ); nextSkeletonEvent = CreateEvent( NULL, TRUE, FALSE, NULL ); drawDepth = new ImageDraw(); result = drawDepth->Initialize( GetDlgItem( hWnd, 1011), d2DFactory, 320, 240, 320 * 4); if (!result ) { // Display error regarding the depth. } if ( !result ) { // Display Error regarding the color. } // recource ensurement EnsureDirect2DResources(); //Flags for the kinect, usage is one line under the code. DWORD nuiFlags = NUI_INITIALIZE_FLAG_USES_DEPTH_AND_PLAYER_INDEX | NUI_INITIALIZE_FLAG_USES_SKELETON | NUI_INITIALIZE_FLAG_USES_COLOR; hr = globalNui->NuiInitialize(nuiFlags); //If the skeletal part cannot be initialized, just initialize everything else. if ( E_NUI_SKELETAL_ENGINE_BUSY == hr) { nuiFlags = NUI_INITIALIZE_FLAG_USES_DEPTH_AND_PLAYER_INDEX | NUI_INITIALIZE_FLAG_USES_COLOR; hr = globalNui->NuiInitialize(nuiFlags); } if ( FAILED(hr)) { // Some error which result in the software being unable to properly initialize the kinect. // of nui init error. } if ( HasSkeletalEngine( globalNui ) ) { hr = globalNui->NuiSkeletonTrackingEnable( nextSkeletonEvent, skeletonTrackingFlags); if( FAILED(hr)) { // Error about skeleton tracking. } } // skeletal viewer error //Initialize the color stream hr = globalNui->NuiImageStreamOpen( NUI_IMAGE_TYPE_COLOR, NUI_IMAGE_RESOLUTION_640x480, 0, 2, nextColorFrameEvent, &videoStreamHandle); // error toevoegen voor de image stream if ( FAILED(hr) ) { } //Initialize the depth stream. hr = globalNui->NuiImageStreamOpen( HasSkeletalEngine(globalNui) ? NUI_IMAGE_TYPE_DEPTH_AND_PLAYER_INDEX : NUI_IMAGE_TYPE_DEPTH, NUI_IMAGE_RESOLUTION_320x240, depthStreamFlags, 2, nextDepthFrameEvent, &depthStreamHandle ); // error toevoegen voor de depth stream if ( FAILED(hr) ) { hr = globalNui->NuiImageStreamOpen( HasSkeletalEngine(globalNui) ? NUI_IMAGE_TYPE_DEPTH_AND_PLAYER_INDEX : NUI_IMAGE_TYPE_DEPTH, NUI_IMAGE_RESOLUTION_320x240, NUI_IMAGE_FRAME_FLAG_NONE, 2, nextDepthFrameEvent, &depthStreamHandle ); } //Init the Mutex system ( to prevent read and write on the same object simultaniously ) mutex = CreateMutex(NULL, FALSE,L"D2DBitMapProtector"); //FaceTracker Init faceTracker->init(mutex); // Start the processing thread treadNuiProcessStop = CreateEvent( NULL, FALSE, FALSE, NULL ); treadNuiProcess = CreateThread ( NULL, 0, ProcessThread, this, 0, NULL); //start the facetracker thread faceTracker->startThread(); return hr; }