///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;
}
