/**
* @brief QKinect::tracking : Boucle principale de capture
*/
void QKinect::tracking()
{
// Tant que la capture est demandé
while(isRunning)
{
// Récupération de la frame suivante
HRESULT res = NuiSkeletonGetNextFrame(1, &mSkeletonFrame);
NuiTransformSmooth(&mSkeletonFrame, NULL);
for(int i = 0; i < NUI_SKELETON_COUNT; i++)
{
if(mSkeletonFrame.SkeletonData[i].eTrackingState == NUI_SKELETON_TRACKED)
{
// Vérouillage du mutex pour le vecteur des points de chaque squelettes
mDrawZone->lock();
// Enregistrement des coordonnée de chaque points pour la zone de dessin
mDrawZone->SetSkeleton(i, mSkeletonFrame.SkeletonData[i]);
// Dévérouillage du mutex pour le vecteur des points de chaque squelettes
mDrawZone->unlock();
}
else if(mSkeletonFrame.SkeletonData[i].eTrackingState == NUI_SKELETON_NOT_TRACKED)
{
// Squelette n'est plus traqué, on le retire de la zone de dessin
mDrawZone->RemoveSkeleton(i);
}
}
// Sleep de 30ms pour éviter de pourrir la ressource CPU :)
msleep(30);
}
}
void KinectSensor::GotSkeletonAlert()
{
NUI_SKELETON_FRAME SkeletonFrame = {0};
HRESULT hr = NuiSkeletonGetNextFrame(0, &SkeletonFrame);
if(FAILED(hr))
{
return;
}
for( int i = 0 ; i < NUI_SKELETON_COUNT ; i++ )
{
if( SkeletonFrame.SkeletonData[i].eTrackingState == NUI_SKELETON_TRACKED &&
NUI_SKELETON_POSITION_TRACKED == SkeletonFrame.SkeletonData[i].eSkeletonPositionTrackingState[NUI_SKELETON_POSITION_HEAD] &&
NUI_SKELETON_POSITION_TRACKED == SkeletonFrame.SkeletonData[i].eSkeletonPositionTrackingState[NUI_SKELETON_POSITION_SHOULDER_CENTER])
{
m_SkeletonTracked[i] = true;
m_HeadPoint[i].x = SkeletonFrame.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HEAD].x;
m_HeadPoint[i].y = SkeletonFrame.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HEAD].y;
m_HeadPoint[i].z = SkeletonFrame.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HEAD].z;
m_NeckPoint[i].x = SkeletonFrame.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_SHOULDER_CENTER].x;
m_NeckPoint[i].y = SkeletonFrame.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_SHOULDER_CENTER].y;
m_NeckPoint[i].z = SkeletonFrame.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_SHOULDER_CENTER].z;
}
else
{
m_HeadPoint[i] = m_NeckPoint[i] = FT_VECTOR3D(0, 0, 0);
m_SkeletonTracked[i] = false;
}
}
}
void KinectSensor::GotSkeletonAlert()
{
NUI_SKELETON_FRAME SkeletonFrame = {0};
HRESULT hr = NuiSkeletonGetNextFrame(0, &SkeletonFrame);
if(FAILED(hr))
{
return;
}
int skeletonCount = 0;
for( int i = 0 ; i < NUI_SKELETON_COUNT ; i++ )
{
if (SkeletonFrame.SkeletonData[i].eTrackingState == NUI_SKELETON_TRACKED)
skeletonCount++;
if( SkeletonFrame.SkeletonData[i].eTrackingState == NUI_SKELETON_TRACKED &&
NUI_SKELETON_POSITION_TRACKED == SkeletonFrame.SkeletonData[i].eSkeletonPositionTrackingState[NUI_SKELETON_POSITION_HEAD] &&
NUI_SKELETON_POSITION_TRACKED == SkeletonFrame.SkeletonData[i].eSkeletonPositionTrackingState[NUI_SKELETON_POSITION_SHOULDER_CENTER])
{
m_SkeletonTracked[i] = true;
m_HeadPoint[i].x = SkeletonFrame.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HEAD].x;
m_HeadPoint[i].y = SkeletonFrame.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HEAD].y;
m_HeadPoint[i].z = SkeletonFrame.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HEAD].z;
m_NeckPoint[i].x = SkeletonFrame.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_SHOULDER_CENTER].x;
m_NeckPoint[i].y = SkeletonFrame.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_SHOULDER_CENTER].y;
m_NeckPoint[i].z = SkeletonFrame.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_SHOULDER_CENTER].z;
}
else
{
m_HeadPoint[i] = m_NeckPoint[i] = FT_VECTOR3D(0, 0, 0);
m_SkeletonTracked[i] = false;
}
}
m_Skeletons = cv::Mat::zeros(NUI_SKELETON_COUNT, 21, CV_32FC4);
for (int i = 0; i < NUI_SKELETON_COUNT; i++)
{
if (SkeletonFrame.SkeletonData[i].eTrackingState != NUI_SKELETON_TRACKED)
continue;
for (int j = 0; j < 20; j++){
cv::Vec4f point;
point[0] = SkeletonFrame.SkeletonData[i].SkeletonPositions[j].x;
point[1] = SkeletonFrame.SkeletonData[i].SkeletonPositions[j].y;
point[2] = SkeletonFrame.SkeletonData[i].SkeletonPositions[j].z;
point[3] = SkeletonFrame.SkeletonData[i].eSkeletonPositionTrackingState[j]; // 0,1,2;
m_Skeletons.at<cv::Vec4f>(i, j) = point;
}
}
}
void juego_menu_idle(){
NuiSkeletonGetNextFrame(0, &ourframe);
for(int i=0; i<6; i++){
if(ourframe.SkeletonData[i].eTrackingState == NUI_SKELETON_TRACKED){
//int gestura = decodeGesture(
GLfloat a,b,c;
//ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELET]
a = ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HAND_RIGHT].x;
b = ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HAND_RIGHT].y;
c = 1 - ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HAND_RIGHT].z;
if(mouse->posX >= .80){
mouse->posX = .79;
} else if(mouse->posX <= .20){
mouse->posX = .20;
} else {
mouse->posX += a/50;
}
if(mouse->posY >= .68){
mouse->posY = .67;
} else if(mouse->posY <= .30){
mouse->posY = .30;
} else {
mouse -> posY += b/50;
}
//printf("Mouse -> pos y: %lf\n", mouse->posY);
mouse -> posY += b/50;
if(mouse->posX >= play->posX && mouse->posX < .80) {
if(angle < 8){
loader->posX = centerX + cos(angle) * radX;
loader->posY = centerY + sin(angle) * radY;
angle += orbitSpeed;
} else {
escena->juego->vistaActual = JUEGO_PAUSE;
escena->currentFrame = 0;
creaEscena();
}
} else {
loader->posX = .77;
loader->posY = .37;
}
/*printf("HAND RIGHT X %lf/n", a);
printf("HAND RIGHT Y %lf/n", b);
printf("HAND RIGHT Z %lf/n", c);*/
}
}
}
void juego_pause_idle(){
NuiSkeletonGetNextFrame(0, &ourframe);
Gestures *gestures = new Gestures();
for(int i=0; i<6; i++){
if(ourframe.SkeletonData[i].eTrackingState == NUI_SKELETON_TRACKED){
gestures->setGesture(
gestures->decodeGesture(
ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HAND_RIGHT].x,
ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HAND_RIGHT].y,
ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HAND_RIGHT].z,
ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HAND_LEFT].x,
ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HAND_LEFT].y,
ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HAND_LEFT].z,
ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_SHOULDER_CENTER].x,
ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_SHOULDER_CENTER].y,
ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_SHOULDER_CENTER].z
)
);
switch(gestures->getGesture()){
case CROSS_HANDS:
//cout << "CROSS_HANDS" << endl;
cargando_juego = true;
escena->currentFrame = 0;
creaEscena();
break;
case HORIZONTAL_HANDS:
//cout << "HORIZONTAL HANDS" << endl;
break;
case HANDS_DOWN:
if(cargando_juego){
escena->juego->vistaActual = JUEGO_ACTIVO;
escena->currentFrame = 0;
creaEscena();
}
break;
default:
//cout << "NO DEFINIDO" << endl;
break;
}
}
}
}
void CSkeletalViewerApp::Nui_GotSkeletonAlert( )
{
NUI_SKELETON_FRAME SkeletonFrame;
HRESULT hr = NuiSkeletonGetNextFrame( 0, &SkeletonFrame );
bool bFoundSkeleton = true;
for( int i = 0 ; i < NUI_SKELETON_COUNT ; i++ )
{
if( SkeletonFrame.SkeletonData[i].eTrackingState == NUI_SKELETON_TRACKED )
{
bFoundSkeleton = false;
}
}
// no skeletons!
//
if( bFoundSkeleton )
{
return;
}
// smooth out the skeleton data
NuiTransformSmooth(&SkeletonFrame,NULL);
// we found a skeleton, re-start the timer
m_bScreenBlanked = false;
m_LastSkeletonFoundTime = -1;
// draw each skeleton color according to the slot within they are found.
//
bool bBlank = true;
for( int i = 0 ; i < NUI_SKELETON_COUNT ; i++ )
{
if( SkeletonFrame.SkeletonData[i].eTrackingState == NUI_SKELETON_TRACKED )
{
Nui_DrawSkeleton( bBlank, &SkeletonFrame.SkeletonData[i], GetDlgItem( m_hWnd, IDC_SKELETALVIEW ), i );
bBlank = false;
}
}
Nui_DoDoubleBuffer(GetDlgItem(m_hWnd,IDC_SKELETALVIEW), m_SkeletonDC);
}
void juego_lose_idle(){
NuiSkeletonGetNextFrame(0, &ourframe);
Gestures *gestures = new Gestures();
for(int i=0; i<6; i++){
if(ourframe.SkeletonData[i].eTrackingState == NUI_SKELETON_TRACKED){
gestures->setGesture(
gestures->decodeGesture(
ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HAND_RIGHT].x,
ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HAND_RIGHT].y,
ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HAND_RIGHT].z,
ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HAND_LEFT].x,
ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HAND_LEFT].y,
ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HAND_LEFT].z,
ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_SHOULDER_CENTER].x,
ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_SHOULDER_CENTER].y,
ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_SHOULDER_CENTER].z
)
);
switch(gestures->getGesture()){
case CROSS_HANDS:
//cout << "CROSS_HANDS" << endl;
escena->currentFrame = 0;
escena->juego->tren = 0;
escena->juego->no_vidas = 3;
escena->juego->vistaActual = JUEGO_PAUSE;
creaEscena();
break;
case HORIZONTAL_HANDS:
//exit(0);
break;
case HANDS_DOWN:
//exit(0);
break;
default:
break;
}
}
}
}
void Flyer::do_UPDATE(PE::Events::Event *pEvt)
{
#ifdef _XBOX
PE::Events::Event_UPDATE *pRealEvt = (PE::Events::Event_UPDATE *)(pEvt);
float frameTime = pRealEvt->m_frameTime;
// NUI testing
if( WAIT_OBJECT_0 != WaitForSingleObject( m_hFrameEndEvent, NUI_FRAME_END_TIMEOUT_DEFAULT ) )
{
//return FALSE;
//todo: output this on screen
//PEINFO("NUI Frame not ready yet\n");
}
else
{
/*
// Get data from the next camera color frame
HRESULT hrImage = NuiImageStreamGetNextFrame( m_hImage, 0, &m_pImageFrame );
// Get data from the next camera depth frame
HRESULT hrDepth = NuiImageStreamGetNextFrame( m_hDepth, 0, &m_pDepthFrame );
*/
// Get data from the next skeleton frame
HRESULT hrSkeleton = NuiSkeletonGetNextFrame( 0, &m_SkeletonFrame );
/*
if( SUCCEEDED ( hrImage ) )
{
m_pip.SetColorTexture( m_pImageFrame->pFrameTexture );
NuiImageStreamReleaseFrame( m_hImage, m_pImageFrame );
}
if( SUCCEEDED( hrDepth ) )
{
m_pip.SetDepthTexture( m_pDepthFrame->pFrameTexture );
NuiImageStreamReleaseFrame( m_hDepth, m_pDepthFrame );
}*/
if ( SUCCEEDED( hrSkeleton ) )
{
/*
m_pip.SetSkeletons( &m_SkeletonFrame );
ApplyTiltCorrection( &m_SkeletonFrame );
m_dwCurrentFrameIndex = ( m_dwCurrentFrameIndex + 1 ) & 1;
*/
}
if (++m_framesWithNoData > 30 && m_prevCameraType != CameraManager::CameraType_Count)
{
CameraManager::Instance()->selectActiveCamera(m_prevCameraType);
m_prevCameraType = CameraManager::CameraType_Count;
}
if (SUCCEEDED ( hrSkeleton ) )
{
bool found = false;
// Update if skeleton was tracked
for (UINT uCurrentSkeleton = 0; uCurrentSkeleton < NUI_SKELETON_COUNT; uCurrentSkeleton++)
{
if ( m_SkeletonFrame.SkeletonData[uCurrentSkeleton].eTrackingState == NUI_SKELETON_TRACKED )
{
found = true;
m_JointFilter.Update( &m_SkeletonFrame.SkeletonData[uCurrentSkeleton] );
// exmaple of fetching Positions only
XMVECTOR vHead = m_SkeletonFrame.SkeletonData[uCurrentSkeleton].SkeletonPositions[NUI_SKELETON_POSITION_HEAD];
//Uncomment to enable printout
//PEINFO(Position of head: "%f %f %f\n", vHead.x, vHead.y, vHead.z);
// in case you need orientation of nodes, use the code below
{
m_pNuiJointConverterConstrained->ConvertNuiToAvatarSkeleton(&m_SkeletonFrame.SkeletonData[uCurrentSkeleton], m_AvatarJointPoseNuiMapperConstrained);
m_pNuiJointConverterConstrained->GetNuiSkeletonData(&m_SkeletonFrame.SkeletonData[uCurrentSkeleton]);
Vector3 leftHip, rightHip, hipCenter, leftHand, rightHand, head, leftLeg, rightLeg;
leftHand = m_lastLeftPos;
rightHand = m_lastRightPos;
Matrix4x4 mainBase;
for (int i = 0; i < XAVATAR_MAX_SKELETON_JOINTS; i++)
{
XMVECTOR rot = m_AvatarJointPoseNuiMapperConstrained[i].Rotation;
XMVECTOR pos = m_pNuiJointConverterConstrained->GetAvatarJointWorldPosition(i);//m_AvatarJointPoseNuiMapperConstrained[i].Position;
if (pos.z != 0)
pos.z += 3.0f;
Quaternion q;
q.m_x = rot.x;
q.m_y = rot.y;
q.m_z = rot.z;
q.m_w = rot.w;
Matrix4x4 base(q);
base.setPos(Vector3(pos.x *2.0f, pos.y *2.0f, pos.z * 2.0f));
m_sceneNodes[i]->m_base = base;
if (m_pNuiJointConverterConstrained->MapAvatarJointToIntIndex(i) == 0 )
{
mainBase = base;
}
else if (m_pNuiJointConverterConstrained->MapAvatarJointToNUI_POSITION_INDEX(i) == NUI_SKELETON_POSITION_HEAD )
{
head = base.getPos();
}
else if (m_pNuiJointConverterConstrained->MapAvatarJointToNUI_POSITION_INDEX(i) == NUI_SKELETON_POSITION_KNEE_LEFT )
{
leftLeg = base.getPos();
}
else if (m_pNuiJointConverterConstrained->MapAvatarJointToNUI_POSITION_INDEX(i) == NUI_SKELETON_POSITION_KNEE_RIGHT )
{
rightLeg = base.getPos();
}else if (m_pNuiJointConverterConstrained->MapAvatarJointToNUI_POSITION_INDEX(i) == NUI_SKELETON_POSITION_HIP_CENTER )
{
hipCenter = base.getPos();
} else if (m_pNuiJointConverterConstrained->MapAvatarJointToNUI_POSITION_INDEX(i) == NUI_SKELETON_POSITION_HIP_LEFT )
{
leftHip = base.getPos();
} else if (m_pNuiJointConverterConstrained->MapAvatarJointToNUI_POSITION_INDEX(i) == NUI_SKELETON_POSITION_HIP_RIGHT )
{
rightHip = base.getPos();
}
else if (m_pNuiJointConverterConstrained->MapAvatarJointToNUI_POSITION_INDEX(i) == NUI_SKELETON_POSITION_ELBOW_RIGHT )
{
rightHand = base.getPos();
}
else if (m_pNuiJointConverterConstrained->MapAvatarJointToNUI_POSITION_INDEX(i) == NUI_SKELETON_POSITION_ELBOW_LEFT )
{
leftHand = base.getPos();
}
}
static const float HORIZONTAL_SPEED_FACTOR = 0.5f / 1.0f;
static const float FALL_SPEED_INCREASE = 30.0f / 100.0f;
static const float ASCEND_SPEED_INCREASE = 8.0f / 100.0f;
static const float FALL_MAX_SPEED = 10.0f / 100.0f;
static const float ASCEND_MAX_SPEED = 50.0f / 100.0f;
static const float TURN_SPEED = .5f;
Vector3 dif;
if ((rightHand - m_lastRightPos).m_y < 0)
dif += ( rightHand - m_lastRightPos );
if ((leftHand - m_lastLeftPos).m_y < 0)
dif += ( leftHand - m_lastLeftPos );
dif = -dif;
if (dif.m_y > 0.10f)
{
m_speed.m_y += ASCEND_SPEED_INCREASE * frameTime * dif.m_y * 100.0f;
if (m_speed.m_y > ASCEND_MAX_SPEED)
m_speed.m_y = ASCEND_MAX_SPEED;
}
else
{
// decrease speed
m_speed.m_y -= FALL_SPEED_INCREASE * frameTime;
if (m_speed.m_y < -FALL_MAX_SPEED)
m_speed.m_y = -FALL_MAX_SPEED;
}
Vector3 pos = m_pNuiSN->m_base.getPos();
m_speed.m_x = m_pNuiSN->m_base.getN().m_x;
m_speed.m_z = m_pNuiSN->m_base.getN().m_z;
if (pos.m_y > 1.0f)
{
m_speed.m_x *= HORIZONTAL_SPEED_FACTOR * (pos.m_y-1.0f) * frameTime;
m_speed.m_z *= HORIZONTAL_SPEED_FACTOR * (pos.m_y -1.0f) * frameTime;
}
else
{
m_speed.m_x = 0;
m_speed.m_z = 0;
}
pos += m_speed;
if (pos.m_y < 1.0f)
pos.m_y = 1.0f;
if (pos.m_y > 25.0f)
pos.m_y = 25.0f;
m_pNuiSN->m_base.setPos(pos);
if (hipCenter.m_y - leftLeg.m_y < .9f)
{
m_pNuiSN->m_base.turnRight(TURN_SPEED * frameTime);
}
else if (hipCenter.m_y - rightLeg.m_y < .9f)
{
m_pNuiSN->m_base.turnLeft(TURN_SPEED * frameTime);
}
m_pCamSN->m_base = mainBase;
m_pCamSN->m_base.setPos(hipCenter + Vector3(0, 1.0f, -5.5f));
m_pCamSN->m_base.turnLeft(3.1415f);
m_pCamSN->m_base.turnUp(3.1415f / 8.0f);
SceneNode *pCamSN = CameraManager::Instance()->getCamera(CameraManager::PLAYER)->getCamSceneNode();
pCamSN->m_base = mainBase;
pCamSN->m_base.setPos(hipCenter + Vector3(0, 1.0f, -4.5f));
//pCamSN->m_base.turnLeft(3.1415f);
pCamSN->m_base.turnDown(3.1415f / 8.0f);
m_lastRightPos = rightHand;
m_lastLeftPos = leftHand;
m_framesWithNoData = 0;
if (m_prevCameraType == CameraManager::CameraType_Count)
m_prevCameraType = CameraManager::Instance()->getActiveCameraType(); // code will know to reset it back to prev cam
CameraManager::Instance()->selectActiveCamera(CameraManager::PLAYER);
}
//UpdateNUI( &m_CameraManager.GetSkeleton()->SkeletonData[uCurrentSkeleton] );
break;
}
}
if (found)
m_framesWithData++;
else
m_framesWithData = 0;
}
else
m_framesWithData = 0;
}
#endif
}
void KinectGrabber::Kinect_GotSkeletonAlert( )
{
NUI_SKELETON_FRAME SkeletonFrame;
HRESULT hr = NuiSkeletonGetNextFrame( 0, &SkeletonFrame );
isSkeletonTracked=false;
//POINT m_Points[NUI_SKELETON_POSITION_COUNT];
for( int i = 0 ; i < NUI_SKELETON_COUNT ; i++ )
{
if( SkeletonFrame.SkeletonData[i].eTrackingState == NUI_SKELETON_TRACKED )
{
isSkeletonTracked=true;
int scaleX = VIDEO_WIDTH; //scaling up to image coordinates
int scaleY = VIDEO_HEIGHT;
USHORT depthValue;
float fx=0,fy=0;
//POINT m_Points[NUI_SKELETON_POSITION_COUNT];
NUI_SKELETON_DATA * pSkel;
for (int j = 0; j < NUI_SKELETON_POSITION_COUNT; j++)
{
pSkel=& SkeletonFrame.SkeletonData[i];
NuiTransformSkeletonToDepthImageF( pSkel->SkeletonPositions[j], &fx, &fy, &depthValue);
m_Points[j].x = (int) ( fx * scaleX + 0.5f );
m_Points[j].y = (int) ( fy * scaleY + 0.5f );
// make sure to shift depth by 3 bits
m_playerJointDepth[j] = depthValue >> 3;
//m_playerJointDepth[j] = depthValue;
}
// Store the values of the head position of each skeleton
headXValues[i] = m_Points[3].x;
headYValues[i] = m_Points[3].y;
headZValues[i] = m_playerJointDepth[3];
leftShoulderXValues[i]=m_Points[4].x;
rightShoulderXValues[i]=m_Points[8].x;
leftHandXValues[i]=m_Points[7].x;
leftHandYValues[i]=m_Points[7].y;
rightHandXValues[i]=m_Points[11].x;
rightHandYValues[i]=m_Points[11].y;
/*
if(m_Points[3].x!=0){
//printf("headPosition");
//printf("head Z=%4.2f /r", m_Points[3].x);
//printf("%d\n",m_Points[3].x);
//return m_Points[NUI_SKELETON_POSITION_COUNT];
}else{
NuiSkeletonGetNextFrame( 0, &SkeletonFrame );
}
*/
/*
float head_z=SkeletonFrame.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HEAD].z;
if (head_z!=0){
printf("head Z=%4.2f /r", head_z);
}else{
NuiSkeletonGetNextFrame( 0, &SkeletonFrame );
}
*/
} else {
void Device::run()
{
HANDLE events[ 4 ];
events[ 0 ] = mColorEvent;
events[ 1 ] = mDepthEvent;
events[ 2 ] = mSkeletonEvent;
while ( mCapture ) {
if ( mSensor != 0 ) {
double time = getElapsedSeconds();
WaitForMultipleObjects( sizeof( events ) / sizeof( events[ 0 ]), events, 0, WAIT_TIME );
const NUI_IMAGE_FRAME* frameColor = 0;
const NUI_IMAGE_FRAME* frameDepth = 0;
NUI_SKELETON_FRAME frameSkeleton = { 0 };
bool readColor = !mNewColorSurface;
bool readDepth = !mNewDepthSurface;
bool readSkeleton = !mNewSkeletons;
/*if ( mDeviceOptions.isFrameSyncEnabled() && mDeviceOptions.isColorEnabled() && mDeviceOptions.isDepthEnabled() ) {
if ( readColor != readDepth ) {
readColor = false;
readDepth = false;
}
readSkeleton = readDepth;
}*/
readColor = readColor && mDeviceOptions.isColorEnabled();
readDepth = readDepth && mDeviceOptions.isDepthEnabled();
readSkeleton = readSkeleton && mDeviceOptions.isSkeletonTrackingEnabled();
//////////////////////////////////////////////////////////////////////////////////////////////
if ( readDepth && WAIT_OBJECT_0 == WaitForSingleObject( mDepthEvent, 0 ) ) {
if ( SUCCEEDED( NuiImageStreamGetNextFrame( mDepthStreamHandle, 0, &frameDepth ) ) &&
frameDepth != 0 && frameDepth->pFrameTexture != 0 ) {
mDepthTimeStamp = frameDepth->liTimeStamp.QuadPart;
INuiFrameTexture* texture = frameDepth->pFrameTexture;
_NUI_LOCKED_RECT lockedRect;
long hr = texture->LockRect( 0, &lockedRect, 0, 0 );
if ( FAILED( hr ) ) {
error( hr );
}
if ( lockedRect.Pitch == 0 ) {
console() << "Invalid buffer length received" << endl;
} else {
pixelToDepthSurface( (uint16_t*)lockedRect.pBits );
}
hr = NuiImageStreamReleaseFrame( mDepthStreamHandle, frameDepth );
if ( FAILED( hr ) ) {
error( hr );
}
mUserCount = 0;
for ( uint32_t i = 0; i < NUI_SKELETON_COUNT; ++i ) {
if ( mActiveUsers[ i ] ) {
++mUserCount;
}
}
mNewDepthSurface = true;
}
}
//////////////////////////////////////////////////////////////////////////////////////////////
if ( readColor && WAIT_OBJECT_0 == WaitForSingleObject( mColorEvent, 0 ) ) {
if ( SUCCEEDED( NuiImageStreamGetNextFrame( mColorStreamHandle, 0, &frameColor ) ) &&
frameColor != 0 && frameColor->pFrameTexture != 0 ) {
INuiFrameTexture* texture = frameColor->pFrameTexture;
_NUI_LOCKED_RECT lockedRect;
long hr = texture->LockRect( 0, &lockedRect, 0, 0 );
if ( FAILED( hr ) ) {
error( hr );
}
if ( lockedRect.Pitch != 0 ) {
pixelToColorSurface( (uint8_t*)lockedRect.pBits );
/*if ( mDeviceOptions.isFrameSyncEnabled() ) {
mColorFrames.push_back( ColorFrame( mColorSurface, frameColor->liTimeStamp.QuadPart ) );
if ( mColorFrames.size() > 10 ) {
mColorFrames.erase( mColorFrames.begin() );
}
}*/
} else {
console() << "Invalid buffer length received." << endl;
}
hr = NuiImageStreamReleaseFrame( mColorStreamHandle, frameColor );
if ( FAILED( hr ) ) {
error( hr );
}
mNewColorSurface = true;
}
}
//////////////////////////////////////////////////////////////////////////////////////////////
if ( readSkeleton && WAIT_OBJECT_0 == WaitForSingleObject( mSkeletonEvent, 0 ) ) {
long hr = NuiSkeletonGetNextFrame( 0, &frameSkeleton );
if ( SUCCEEDED( hr ) ) {
bool foundSkeleton = false;
for ( int32_t i = 0; i < NUI_SKELETON_COUNT; ++i ) {
mSkeletons.at( i ).clear();
NUI_SKELETON_TRACKING_STATE trackingState = frameSkeleton.SkeletonData[ i ].eTrackingState;
if ( trackingState == NUI_SKELETON_TRACKED || trackingState == NUI_SKELETON_POSITION_ONLY ) {
if ( !foundSkeleton ) {
_NUI_TRANSFORM_SMOOTH_PARAMETERS transform = kTransformParams[ mTransform ];
hr = mSensor->NuiTransformSmooth( &frameSkeleton, &transform );
if ( FAILED( hr ) ) {
error( hr );
}
foundSkeleton = true;
}
if ( mFlipped ) {
( frameSkeleton.SkeletonData + i )->Position.x *= -1.0f;
for ( int32_t j = 0; j < (int32_t)NUI_SKELETON_POSITION_COUNT; ++j ) {
( frameSkeleton.SkeletonData + i )->SkeletonPositions[ j ].x *= -1.0f;
}
}
_NUI_SKELETON_BONE_ORIENTATION bones[ NUI_SKELETON_POSITION_COUNT ];
hr = NuiSkeletonCalculateBoneOrientations( frameSkeleton.SkeletonData + i, bones );
if ( FAILED( hr ) ) {
error( hr );
}
for ( int32_t j = 0; j < (int32_t)NUI_SKELETON_POSITION_COUNT; ++j ) {
Bone bone( *( ( frameSkeleton.SkeletonData + i )->SkeletonPositions + j ), *( bones + j ) );
( mSkeletons.begin() + i )->insert( std::pair<JointName, Bone>( (JointName)j, bone ) );
}
}
}
mNewSkeletons = true;
}
mFrameRate = (float)( 1.0 / ( time - mReadTime ) );
mReadTime = time;
}
}
}
return;
}
//-------------------------------------------------------------------
// Nui_GotSkeletonAlert
//
// Handle new skeleton data
//-------------------------------------------------------------------
void SkeletalTracker::Nui_GotSkeletonAlert( )
{
NUI_SKELETON_FRAME SkeletonFrame = {0};
bool bFoundSkeleton = false;
if ( SUCCEEDED(NuiSkeletonGetNextFrame( 0, &SkeletonFrame )) )
// if ( SUCCEEDED(m_pNuiSensor->NuiSkeletonGetNextFrame( 0, &SkeletonFrame )) )
{
for ( int i = 0 ; i < NUI_SKELETON_COUNT ; i++ )
{
// if( SkeletonFrame.SkeletonData[i].eTrackingState == NUI_SKELETON_TRACKED ||
// (SkeletonFrame.SkeletonData[i].eTrackingState == NUI_SKELETON_POSITION_ONLY ))
{
bFoundSkeleton = true;
}
}
}
// no skeletons!
if( !bFoundSkeleton )
{
return;
}
// smooth out the skeleton data
NUI_TRANSFORM_SMOOTH_PARAMETERS smoothParams;
smoothParams.fSmoothing = 0.6f;
smoothParams.fCorrection = 0.3f;
smoothParams.fPrediction = 0.6f;
smoothParams.fJitterRadius = 0.6f;
smoothParams.fMaxDeviationRadius = 0.6f;
HRESULT hr = NuiTransformSmooth(&SkeletonFrame,&smoothParams);
// HRESULT hr = NuiTransformSmooth(&SkeletonFrame,&smoothParams);
if ( FAILED(hr) )
{
return;
}
// we found a skeleton, re-start the skeletal timer
bool bSkeletonIdsChanged = false;
USHORT currentMaxDepth = NUI_IMAGE_DEPTH_MAXIMUM;
int selectedSkeleton = -1;
for ( int i = 0 ; i < NUI_SKELETON_COUNT; i++ )
{
if ( m_SkeletonIds[i] != SkeletonFrame.SkeletonData[i].dwTrackingID )
{
m_SkeletonIds[i] = SkeletonFrame.SkeletonData[i].dwTrackingID;
bSkeletonIdsChanged = true;
}
// Show skeleton only if it is tracked, and the center-shoulder joint is at least inferred.
if ( SkeletonFrame.SkeletonData[i].eTrackingState == NUI_SKELETON_TRACKED)
{
LONG x, y;
USHORT depth;
// Transform skeleton coordinates to depth image
NuiTransformSkeletonToDepthImage(SkeletonFrame.SkeletonData[i].Position, &x, &y, &depth);
if (depth < currentMaxDepth)
{
selectedSkeleton = i;
currentMaxDepth = depth;
}
}
else if ( SkeletonFrame.SkeletonData[i].eTrackingState == NUI_SKELETON_POSITION_ONLY )
{
// OutputDebugString( L"Skeleton position only\r\n" );
}
}
if (selectedSkeleton > -1)
{
Nui_DrawSkeleton( &SkeletonFrame.SkeletonData[selectedSkeleton], NULL, selectedSkeleton );
}
}
void juego_activo_idle(){
//Inicializar las velocidades
avion1->velZ = x;
avion2->velY = (-1)*x;
avion1->posY -=.2;
indicadorAltActual->posY -=0.0022;
NuiSkeletonGetNextFrame(0, &ourframe);
Gestures *gestures = new Gestures();
for(int i=0; i<6; i++){
if(ourframe.SkeletonData[i].eTrackingState == NUI_SKELETON_TRACKED){
gestures->setGesture(
gestures->decodeGesture(
ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HAND_RIGHT].x,
ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HAND_RIGHT].y,
ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HAND_RIGHT].z,
ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HAND_LEFT].x,
ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HAND_LEFT].y,
ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HAND_LEFT].z,
ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_SHOULDER_CENTER].x,
ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_SHOULDER_CENTER].y,
ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_SHOULDER_CENTER].z
)
);
switch(gestures->getGesture()){
case CROSS_HANDS:
avion1->velX = 0;
avion1->rotZ = 0;
avion1->rotX = 0;
avion2->velX = 0;
avion2->rotZ = 0;
avion2->rotX = 0;
avion3->velX = 0;
avion3->rotZ = 0;
avion3->rotX = 0;
x = 0;
//cout << "CROSS HANDS" << endl;
break;
case HORIZONTAL_HANDS:
//x = 0;
//cout << "HORIZONTAL HANDS" << endl;
izq = ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HAND_LEFT].y;
der = ourframe.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HAND_RIGHT].y;
if(izq < der){
avion1->rotZ += 1;
avion1->velX = -.05;
avion2->velX = -.05;
avion3->rotZ += 1;
estatusGestura->defineMaterial(1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0,
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0,
"izquierda.tga", GL_REPEAT, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, GL_OBJECT_LINEAR, false);
} else if(izq > der){
avion1->rotZ -= 1;
avion1->velX = .05;
avion2->velX = .05;
avion3->rotZ -= 1;
estatusGestura->defineMaterial(1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0,
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0,
"derecha.tga", GL_REPEAT, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, GL_OBJECT_LINEAR, false);
}
break;
case EQUAL_RIGHT_HANDS:
//x = 0;
avion1->velX = 0;
avion1->rotZ = 0;
avion1->rotX = 30;
estatusGestura->defineMaterial(1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0,
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0,
"tren.tga", GL_REPEAT, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, GL_OBJECT_LINEAR, false);
//cout << "EQUAL RIGHT HANDS" << endl;
escena->juego->tren = 1;
break;
case EQUAL_LEFT_HANDS:
//x = 0;
avion1->velX = 0;
avion1->rotZ = 0;
avion1->rotX = 30;
//cout << "EQUAL LEFT HANDS" << endl;
estatusGestura->defineMaterial(1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0,
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0,
"tren.tga", GL_REPEAT, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, GL_OBJECT_LINEAR, false);
escena->juego->tren = 1;
break;
case HANDS_UP:
//cout << "HANDS UP" << endl;
//TODO
avion1->rotX -=1;
//avion1->posY -=1;
avion1->velX = 0;
avion3->rotX -=1;
estatusGestura->defineMaterial(1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0,
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0,
"sube.tga", GL_REPEAT, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, GL_OBJECT_LINEAR, false);
//x= 0;
break;
case HANDS_DOWN:
//cout << "HANDS DOWN" << endl;
avion1->rotX +=1;
//avion1->posY +=1;
avion1->velX = 0;
avion3->rotX +=1;
estatusGestura->defineMaterial(1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0,
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0,
"baja.tga", GL_REPEAT, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, GL_OBJECT_LINEAR, false);
//x = 0;
break;
case DOWN_L_LEFT_HANDS:
//cout << "DOWN L LEFT HANDS" << endl;
x -= .005;
avion1->velX = 0;
estatusGestura->defineMaterial(1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0,
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0,
"desacelera.tga", GL_REPEAT, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, GL_OBJECT_LINEAR, false);
break;
case DOWN_L_RIGHT_HANDS:
//cout << "DOWN L RIGHT HANDS" << endl;
x += .005;
avion1->velX = 0;
estatusGestura->defineMaterial(1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0,
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0,
"acelera.tga", GL_REPEAT, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, GL_OBJECT_LINEAR, false);
break;
default:
//cout << "NO DEFINIDO" << endl;
break;
}
}
if(escena->currentFrame >= 200){
x -= .005;
/*if(avion1->rotX >= 0 && avion1->rotX<= 1){
avion1->rotX = 0;
} else {
avion1->rotX -= 1;
} */
//printf("Rotacion %f \n", avion1->rotX);
//printf("Velocidad %f \n", x);
}
//Hacer un método para manejar el marco del cubo de posiciones
//Mantener la velocidad al momento de que el avión llegue
if(x < .1 && x != 0){
x = .1;
}
//Posicionar el avion a la hora del aterrizaje
if(avion1->posY <= -3.7){
//avion1->rotX = -10;
avion1->posY = -3.8;
//avion3->rotX = -10;
}
if(indicadorAltActual->posY <= -0.3){
indicadorAltActual->posY = -0.3;
}
//printf("%d", escena->juego->tren);
if(avion1->posZ >= .5 && avion1->posZ <= 3){
//printf("LLEGUE A 1000");
//printf("Pos Y %f \n", avion2->posY);
if((avion1->posX < -3.0 || avion1->posX > 3.0 || avion1->rotY > 10 || avion1->rotY < -10 || escena->juego->tren == 0) ){
escena->juego->muerte++;
}
x = 0;
y = 0;
escena->juego->no_vidas -= 1;
if(escena->juego->no_vidas <= 0){
if(escena->juego->muerte <= 0){
//escena->juego->tren = 0;
escena->juego->vistaActual = JUEGO_WIN;
escena->juego->muerte = 0;
escena->currentFrame = 0;
avion1->rotX = 30;
avion1->posY = 50;
x = .4;
avion1->posZ = -100;
avion2->rotX = 90;
avion2->posY = 94;
y = - .4;
creaEscena();
}else{
escena->juego->tren = 0;
escena->juego->vistaActual = JUEGO_LOSE;
escena->juego->muerte = 0;
escena->currentFrame = 0;
avion1->rotX = 30;
avion1->posY = 50;
x = .4;
avion1->posZ = -100;
avion2->rotX = 90;
avion2->posY = 94;
y = - .4;
creaEscena();
}
} else {
if(escena->juego->tren >= 1 && avion1->posY > -3.0){
avion1->rotX = 30;
avion1->posY = 50;
x = .4;
avion1->posZ = -100;
avion2->rotX = 90;
avion2->posY = 94;
y = - .4;
escena->juego->tren = 0;
escena->juego->vistaActual = JUEGO_LOSE;
escena->currentFrame = 0;
creaEscena();
}else
if(escena->juego->muerte <= 0){
juegoActivo();
avion1->rotX = 30;
avion1->posY = 50;
x = .4;
avion1->posZ = -100;
avion2->rotX = 90;
avion2->posY = 94;
y = - .4;
escena->currentFrame = 0;
}else{
escena->juego->tren = 0;
avion1->rotX = 30;
avion1->posY = 50;
x = .4;
avion1->posZ = -100;
avion2->rotX = 90;
avion2->posY = 94;
y = - .4;
escena->juego->vistaActual = JUEGO_LOSE;
escena->currentFrame = 0;
creaEscena();
}
}
}
}
}
DWORD WINAPI Kinect::nuiProcessThread(LPVOID pParam) {
Kinect *pthis = (Kinect *)pParam;
HRESULT hr;
KINECT_LOCKED_RECT LockedRect;
while(1) {
int nEventIdx=WaitForMultipleObjects(sizeof(pthis->_events)/sizeof(pthis->_events[0]),pthis->_events,FALSE,100);
if(nEventIdx==0)
break;
switch(nEventIdx){
case 1:
hr = NuiImageStreamGetNextFrame(
pthis->_depthHandle,
0,
&pthis->_pDepthFrame);
pthis->_pDepthFrame->pFrameTexture->LockRect(0, &LockedRect, NULL, 0);
EnterCriticalSection(&pthis->_csVideo);
if(LockedRect.Pitch !=0) {
BYTE* pBuffer = (BYTE*) LockedRect.pBits;
memcpy(pthis->_depthImg->imageData,pBuffer, (pthis->_depthImg->widthStep)*(pthis->_depthImg->height));
}
LeaveCriticalSection(&pthis->_csVideo);
NuiImageStreamReleaseFrame(pthis->_depthHandle,pthis->_pDepthFrame);
break;
case 2:
hr = NuiImageStreamGetNextFrame(
pthis->_videoHandle,
0,
&pthis->_pVideoFrame);
pthis->_pVideoFrame->pFrameTexture->LockRect(0, &LockedRect, NULL, 0);
EnterCriticalSection(&pthis->_csDepth);
if( LockedRect.Pitch != 0 ) {
BYTE* pBuffer = (BYTE*) LockedRect.pBits;
for( int y = 0 ; y < 480 ; y++ ) {
for( int x = 0 ; x < 640 ; x++) {
pthis->_videoImg->imageData[y*pthis->_videoImg->widthStep+x*pthis->_videoImg->nChannels+0] = *pBuffer++;
pthis->_videoImg->imageData[y*pthis->_videoImg->widthStep+x*pthis->_videoImg->nChannels+1] = *pBuffer++;
pthis->_videoImg->imageData[y*pthis->_videoImg->widthStep+x*pthis->_videoImg->nChannels+2] = *pBuffer++;
pBuffer++;
}
}
}
LeaveCriticalSection(&pthis->_csDepth);
NuiImageStreamReleaseFrame(pthis->_videoHandle,pthis->_pVideoFrame);
break;
case 3:
hr = NuiSkeletonGetNextFrame( 0, &pthis->_skeletonFrame );
NuiTransformSmooth(&pthis->_skeletonFrame,NULL);
EnterCriticalSection(&pthis->_csSkeleton);
//스켈레톤 데이터 변환
LeaveCriticalSection(&pthis->_csSkeleton);
break;
}
}
return 0;
}
/* The matlab mex function */
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
HRESULT hr;
// Get pointer to Kinect handles
unsigned __int64 *MXadress;
if(nrhs==0) {
mexErrMsgTxt("Give Pointer to Kinect as input");
}
MXadress = (unsigned __int64*)mxGetData(prhs[0]);
int depthwidth=(int)MXadress[7];
int depthheight=(int)MXadress[8];
// Initialize Output Skeleton Array
int Jdimsc[2];
Jdimsc[0]=200; Jdimsc[1]=6;
plhs[0] = mxCreateNumericArray(2, Jdimsc, mxDOUBLE_CLASS, mxREAL);
double *Pos;
Pos = mxGetPr(plhs[0]);
NUI_SKELETON_FRAME SkeletonFrame;
// Wait for a Skeleton_Frame to arrive
hr = NuiSkeletonGetNextFrame( 200, &SkeletonFrame );
if( FAILED( hr ) )
{
printf("Failed to get Frame\r\n");
}
else
{
// Check if there is a Skeleton found
bool NoSkeletonFound = true;
for( int i = 0 ; i < NUI_SKELETON_COUNT ; i++ )
{
if( SkeletonFrame.SkeletonData[i].eTrackingState == NUI_SKELETON_TRACKED )
{
NoSkeletonFound = false;
}
}
if( NoSkeletonFound ) { return; }
// Smooth the skeleton data
NuiTransformSmooth(&SkeletonFrame,NULL);
// Copy Skeleton points to output array
int r=0;
for( int i = 0 ; i < NUI_SKELETON_COUNT ; i++ )
{
if( SkeletonFrame.SkeletonData[i].eTrackingState == NUI_SKELETON_TRACKED )
{
NUI_SKELETON_DATA * pSkel = &SkeletonFrame.SkeletonData[i];
int j;
float fx=0,fy=0;
for (j = 0; j < NUI_SKELETON_POSITION_COUNT; j++)
{
Pos[j+r]=i+1;
Pos[j+r+Jdimsc[0]]=pSkel->SkeletonPositions[j].x;
Pos[j+r+Jdimsc[0]*2]=pSkel->SkeletonPositions[j].y;
Pos[j+r+Jdimsc[0]*3]=pSkel->SkeletonPositions[j].z;
NuiTransformSkeletonToDepthImage( pSkel->SkeletonPositions[j], &fx, &fy );
Pos[j+r+Jdimsc[0]*4] = (double) ( fx * depthwidth + 0.5f );
Pos[j+r+Jdimsc[0]*5] = (double) ( fy * depthheight + 0.5f );
}
r+=NUI_SKELETON_POSITION_COUNT;
}
}
}
}
