/**
* Constructor of the class.
* @param ud pointer to a User Detector type.
* @param sa pointer to a Scene Analyzer type.
* @param zd pointer to Zamus Listener type.
* @ṕaram ld pointer to Linq Listener type.
* @param mp max numer of players allowed.
*/
SuperFiremanBrothers :: SuperFiremanBrothers (UserDetector *ud,
SceneAnalyzer *sa,
Zamus *zd,
Linq *ld,
int mp)
{
XnPlane3D floor;
DepthGenerator dgen;
dgen = ud -> retDepthGenerator();
sa -> GetFloor(floor);
dgen.ConvertRealWorldToProjective(1,
&floor.ptPoint,
&floor.ptPoint);
floorLevel = floor.ptPoint.Y + 100;
userDetector = ud;
sceneAnalyzer = sa;
zamusDetector = zd;
linqDetector = ld;
players = map <XnUserID, int> ();
fireBalls = vector <Flame> (MAX_FIREBALLS, Flame());
level = 0;
numFlames = 0;
maxPlayers = mp;
winGame = false;
lostGame = false;
gameStatus = NOT_STARTED;
flameModel = FlameModel();
}
void glutKeyboard (unsigned char key, int x, int y)
{
switch (key)
{
case 27:
exit (1);
case '1':
g_nViewState = DISPLAY_MODE_OVERLAY;
g_depth.GetAlternativeViewPointCap().SetViewPoint(g_image);
break;
case '2':
g_nViewState = DISPLAY_MODE_DEPTH;
g_depth.GetAlternativeViewPointCap().ResetViewPoint();
break;
case '3':
g_nViewState = DISPLAY_MODE_IMAGE;
g_depth.GetAlternativeViewPointCap().ResetViewPoint();
break;
case 's':
takePhoto();
break;
case 'm':
g_context.SetGlobalMirror(!g_context.GetGlobalMirror());
break;
}
}
void GeneratePointCloud(DepthGenerator& rDepthGen, const XnDepthPixel* pDepth, VISION_DATA &pData)
{
DepthMetaData mDepthMD;
rDepthGen.GetMetaData(mDepthMD);
pData.timeStamp = mDepthMD.Timestamp();
unsigned int uPointNum = mDepthMD.FullXRes() * mDepthMD.FullYRes();
XnPoint3D* pDepthPointSet = new XnPoint3D[uPointNum];
unsigned int i, j, idxshift, idx;
for( j = 0; j < mDepthMD.FullYRes(); ++j)
{
idxshift = j * mDepthMD.FullXRes();
for(i = 0; i < mDepthMD.FullXRes(); ++i)
{
idx = idxshift + i;
pDepthPointSet[idx].X = i;
pDepthPointSet[idx].Y = j;
pDepthPointSet[idx].Z = pDepth[idx];
}
}
XnPoint3D* p3DPointSet = new XnPoint3D[uPointNum];
rDepthGen.ConvertProjectiveToRealWorld(uPointNum, pDepthPointSet, p3DPointSet);
memcpy(pData.pointCloud, p3DPointSet, uPointNum*3*sizeof(float));
delete[] pDepthPointSet;
delete[] p3DPointSet;
}
void OpenNIUser::renderBone( int joint1, int joint2 )
{
DepthGenerator* depth = _device->getDepthGenerator();
if( !depth ) return;
OpenNIBone* bone1 = mBoneList[joint1-1];
OpenNIBone* bone2 = mBoneList[joint2-1];
// Convert a point from world coordinates to screen coordinates
XnPoint3D point1, point2;
XnPoint3D realJointPos1, realJointPos2;
realJointPos1.X = bone1->position[0];
realJointPos1.Y = bone1->position[1];
realJointPos1.Z = bone1->position[2];
realJointPos2.X = bone2->position[0];
realJointPos2.Y = bone2->position[1];
realJointPos2.Z = bone2->position[2];
depth->ConvertRealWorldToProjective( 1, &realJointPos1, &point1 );
depth->ConvertRealWorldToProjective( 1, &realJointPos2, &point2 );
glLineWidth( 2 );
glBegin( GL_LINES );
glColor4f( mColor[0], mColor[1], mColor[2], 1 );
glVertex3f( point1.X, point1.Y, 0 ); //point.Z );
glVertex3f( point2.X, point2.Y, 0 ); //point.Z );
glEnd();
}
int main()
{
XnStatus nRetVal = XN_STATUS_OK;
Context context;
nRetVal = context.Init();
CHECK_RC(nRetVal, "Initialize context");
DepthGenerator depth;
nRetVal = depth.Create(context);
CHECK_RC(nRetVal, "Create depth generator");
nRetVal = context.StartGeneratingAll();
CHECK_RC(nRetVal, "StartGeneratingAll");
DepthMetaData depthMD;
while (!xnOSWasKeyboardHit())
{
nRetVal = context.WaitOneUpdateAll(depth);
if (nRetVal != XN_STATUS_OK)
{
printf("UpdateData failed: %s\n", xnGetStatusString(nRetVal));
continue;
}
depth.GetMetaData(depthMD);
const XnDepthPixel* pDepthMap = depthMD.Data();
printf("Frame %d Middle point is: %u.\n", depthMD.FrameID(), depthMD(depthMD.XRes() / 2, depthMD.YRes() / 2));
}
context.Shutdown();
return 0;
}
void seekFrame(int nDiff)
{
XnStatus nRetVal = XN_STATUS_OK;
if (isPlayerOn())
{
const XnChar* strNodeName = NULL;
if (g_pPrimary != NULL)
{
strNodeName = g_pPrimary->GetName();
}
else if (g_Depth.IsValid())
{
strNodeName = g_Depth.GetName();
}
else if (g_Image.IsValid())
{
strNodeName = g_Image.GetName();
}
else if (g_IR.IsValid())
{
strNodeName = g_IR.GetName();
}
else if (g_Audio.IsValid())
{
strNodeName = g_Audio.GetName();
}
nRetVal = g_Player.SeekToFrame(strNodeName, nDiff, XN_PLAYER_SEEK_CUR);
if (nRetVal != XN_STATUS_OK)
{
displayMessage("Failed to seek: %s", xnGetStatusString(nRetVal));
return;
}
XnUInt32 nFrame = 0;
XnUInt32 nNumFrames = 0;
nRetVal = g_Player.TellFrame(strNodeName, nFrame);
if (nRetVal != XN_STATUS_OK)
{
displayMessage("Failed to tell frame: %s", xnGetStatusString(nRetVal));
return;
}
nRetVal = g_Player.GetNumFrames(strNodeName, nNumFrames);
if (nRetVal != XN_STATUS_OK)
{
displayMessage("Failed to get number of frames: %s", xnGetStatusString(nRetVal));
return;
}
displayMessage("Seeked %s to frame %u/%u", strNodeName, nFrame, nNumFrames);
}
}
int main()
{
XnStatus nRetVal = XN_STATUS_OK;
Context context;
EnumerationErrors errors;
nRetVal = context.InitFromXmlFile(SAMPLE_XML_PATH, &errors);
if (nRetVal == XN_STATUS_NO_NODE_PRESENT)
{
XnChar strError[1024];
errors.ToString(strError, 1024);
printf("%s\n", strError);
return (nRetVal);
}
else if (nRetVal != XN_STATUS_OK)
{
printf("Open failed: %s\n", xnGetStatusString(nRetVal));
return (nRetVal);
}
DepthGenerator depth;
nRetVal = context.FindExistingNode(XN_NODE_TYPE_DEPTH, depth);
CHECK_RC(nRetVal, "Find depth generator");
XnFPSData xnFPS;
nRetVal = xnFPSInit(&xnFPS, 180);
CHECK_RC(nRetVal, "FPS Init");
DepthMetaData depthMD;
while (!xnOSWasKeyboardHit())
{
nRetVal = context.WaitOneUpdateAll(depth);
if (nRetVal != XN_STATUS_OK)
{
printf("UpdateData failed: %s\n", xnGetStatusString(nRetVal));
continue;
}
xnFPSMarkFrame(&xnFPS);
depth.GetMetaData(depthMD);
const XnDepthPixel* pDepthMap = depthMD.Data();
printf("Frame %d Middle point is: %u. FPS: %f\n", depthMD.FrameID(), depthMD(depthMD.XRes() / 2, depthMD.YRes() / 2), xnFPSCalc(&xnFPS));
}
context.Shutdown();
return 0;
}
// Gets the colour and depth data from the Kinect sensor.
bool GetColorAndDepthImages(ColorImage& colorImage, DepthImage& depthImage)
{
XnStatus rc = XN_STATUS_OK;
// Read a new frame, blocking operation
rc = deviceContext.WaitAnyUpdateAll();
if (rc != XN_STATUS_OK)
{
/*LOGE("Read failed: %s\n", xnGetStatusString(rc));*/
throw rc;
}
// Get handles to new data
static ImageMetaData colorImageMetaData;
static DepthMetaData depthImageMetaData;
colorImageGenerator.GetMetaData(colorImageMetaData);
depthImageGenerator.GetMetaData(depthImageMetaData);
// Validate images
if (!depthImageGenerator.IsValid() || !colorImageGenerator.IsValid())
{
/*LOGE("Error: Color or depth image is invalid.");*/
throw 1;
}
if (colorImageMetaData.Timestamp() <= mostRecentRGB)
return false;
// Fetch pointers to data
const XnRGB24Pixel* pColorImage = colorImageMetaData.RGB24Data(); //g_depth.GetRGB24ImageMap()
const XnDepthPixel* pDepthImage = depthImageMetaData.Data();// g_depth.GetDepthMap();
// Copy data over to arrays
memcpy(colorImage.data, pColorImage, sizeof(colorImage.data));
memcpy(depthImage.data, pDepthImage, sizeof(depthImage.data));
colorImage.rows = colorImage.maxRows;
colorImage.cols = colorImage.maxCols;
depthImage.rows = depthImage.maxRows;
depthImage.cols = depthImage.maxCols;
mostRecentRGB = colorImageMetaData.Timestamp();
return true;
}
void calculateHistogram()
{
DepthGenerator* pDepthGen = getDepthGenerator();
if (pDepthGen == NULL)
return;
XnUInt32 nZRes = pDepthGen->GetDeviceMaxDepth() + 1;
if (g_pDepthHist == NULL)
{
g_pDepthHist = new float[nZRes];
}
xnOSMemSet(g_pDepthHist, 0, nZRes*sizeof(float));
int nNumberOfPoints = 0;
XnDepthPixel nValue;
const XnDepthPixel* pDepth = pDepthGen->GetDepthMap();
const XnDepthPixel* pDepthEnd = pDepth + (pDepthGen->GetDataSize() / sizeof(XnDepthPixel));
while (pDepth != pDepthEnd)
{
nValue = *pDepth;
XN_ASSERT(nValue <= nZRes);
if (nValue != 0)
{
g_pDepthHist[nValue]++;
nNumberOfPoints++;
}
pDepth++;
}
XnUInt32 nIndex;
for (nIndex = 1; nIndex < nZRes; nIndex++)
{
g_pDepthHist[nIndex] += g_pDepthHist[nIndex-1];
}
for (nIndex = 1; nIndex < nZRes; nIndex++)
{
if (g_pDepthHist[nIndex] != 0)
{
g_pDepthHist[nIndex] = (nNumberOfPoints-g_pDepthHist[nIndex]) / nNumberOfPoints;
}
}
}
/**
* Draw the scores over the users in the game (openGL).
*/
void SuperFiremanBrothers :: drawGameInfo ()
{
float y;
int score;
char strLabel[20] = "";
char strLevel[20] = "";
char strStart[20] = "Calibrate to begin";
char strEnd[20] = "Game Over";
UserGenerator uGen;
DepthGenerator dGen;
XnUserID player;
XnPoint3D com;
map <XnUserID, int> :: iterator iter;
float amb[3] = {1.0, 1.0, 1.0};
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, amb);
glDisable(GL_LIGHTING);
y = -768;
uGen = userDetector -> retUserGenerator();
dGen = userDetector -> retDepthGenerator();
for (iter = players.begin(); iter != players.end(); iter++) {
player = iter -> first;
score = iter -> second;
sprintf(strLabel, "Score: %d", score);
uGen.GetCoM(player, com);
dGen.ConvertRealWorldToProjective(1, &com, &com);
glRasterPos3f( com.X + 100, com.Y - 300, com.Z);
glPrintString(GLUT_BITMAP_HELVETICA_18, strLabel);
y += 150;
}
sprintf(strLevel, "Level %d", level);
glRasterPos2f( 500, -768);
glPrintString(GLUT_BITMAP_HELVETICA_18, strLevel);
if (gameStatus == NOT_STARTED) {
glRasterPos2f( 500, 0);
glPrintString(GLUT_BITMAP_HELVETICA_18, strStart);
}
else if (gameStatus > STARTED) {
glRasterPos2f( 500, 0);
glPrintString(GLUT_BITMAP_HELVETICA_18, strEnd);
}
glEnable(GL_LIGHTING);
}
// -----------------------------------------------------------------------------------------------------
// connect
// -----------------------------------------------------------------------------------------------------
bool CameraDevice::connect()
{
//Connect to kinect
printf("Connecting to Kinect... ");
fflush(stdout);
XnStatus nRetVal = XN_STATUS_OK;
EnumerationErrors errors;
ScriptNode script;
nRetVal = g_context.InitFromXmlFile(Config::_PathKinectXmlFile.c_str(), script, &errors);
if (nRetVal == XN_STATUS_NO_NODE_PRESENT)
{
XnChar strError[1024];
errors.ToString(strError, 1024);
printf("%s\n", strError);
return false;
}
else if (nRetVal != XN_STATUS_OK)
{
printf("Open failed: %s\n", xnGetStatusString(nRetVal));
return false;
}
printf("OK\n");
// allocate the point cloud buffer
g_cloudPointSave.width = NBPIXELS_WIDTH;
g_cloudPointSave.height = NBPIXELS_HEIGHT;
g_cloudPointSave.points.resize(NBPIXELS_WIDTH*NBPIXELS_HEIGHT);
nRetVal = g_context.FindExistingNode(XN_NODE_TYPE_DEPTH, g_depth);
CHECK_RC(nRetVal, "Find depth generator");
nRetVal = g_context.FindExistingNode(XN_NODE_TYPE_IMAGE, g_image);
CHECK_RC(nRetVal, "Find image generator");
nRetVal = xnFPSInit(&g_xnFPS, 180);
CHECK_RC(nRetVal, "FPS Init");
g_context.SetGlobalMirror(false); // mirror image horizontally
g_depth.GetAlternativeViewPointCap().SetViewPoint(g_image);
if (g_depth.GetIntProperty ("ShadowValue", g_shadowValue) != XN_STATUS_OK)
printf ("[OpenNIDriver] Could not read shadow value!");
if (g_depth.GetIntProperty ("NoSampleValue", g_noSampleValue) != XN_STATUS_OK)
printf ("[OpenNIDriver] Could not read no sample value!");
return (nRetVal == XN_STATUS_OK);
}
void getJointPosition(XnUserID player, XnSkeletonJoint eJoint1, unsigned char * dest)
{
if (!_userGenerator.GetSkeletonCap().IsTracking(player))
{
printf("not tracked!\n");
return;
}
XnSkeletonJointPosition joint1;
_userGenerator.GetSkeletonCap().GetSkeletonJointPosition(player, eJoint1, joint1);
if (joint1.fConfidence < 0.5)
{
return;
}
XnPoint3D pt[1];
pt[0] = joint1.position;
_depth.ConvertRealWorldToProjective(1, pt, pt);
float _x, _y, _z;
_x = pt[0].X;
_y = pt[0].Y;
_z = pt[0].Z;
memcpy(dest, &_x, 4);
memcpy(dest+4, &_y, 4);
memcpy(dest+8, &_z, 4);
}
void changeRegistration(int nValue)
{
if (!g_Depth.IsValid() || !g_Depth.IsCapabilitySupported(XN_CAPABILITY_ALTERNATIVE_VIEW_POINT))
{
return;
}
if (!nValue)
{
g_Depth.GetAlternativeViewPointCap().ResetViewPoint();
}
else if (g_Image.IsValid())
{
g_Depth.GetAlternativeViewPointCap().SetViewPoint(g_Image);
}
}
// -----------------------------------------------------------------------------------------------------
// generateFrame
// -----------------------------------------------------------------------------------------------------
bool CameraDevice::generateFrame(IplImage* imgRGB, IplImage* imgDepth)
{
XnStatus nRetVal = XN_STATUS_OK;
const XnDepthPixel* pDepthMap = NULL;
const XnRGB24Pixel* pImageMap = NULL;
xnFPSMarkFrame(&g_xnFPS);
nRetVal = g_context.WaitAndUpdateAll();
if (nRetVal==XN_STATUS_OK)
{
g_depth.GetMetaData(g_depthMD);
g_image.GetMetaData(g_imageMD);
pDepthMap = g_depthMD.Data();
pImageMap = g_image.GetRGB24ImageMap();
printf("Frame %02d (%dx%d) Depth at middle point: %u. FPS: %f\r",
g_depthMD.FrameID(),
g_depthMD.XRes(),
g_depthMD.YRes(),
g_depthMD(g_depthMD.XRes()/2, g_depthMD.YRes()/2),
xnFPSCalc(&g_xnFPS));
// convert to OpenCV buffers
convertImageRGB(pImageMap, imgRGB);
convertImageDepth(pDepthMap, imgDepth);
return true;
}
return false;
}
XnStatus prepare(char useScene, char useDepth, char useHistogram)
{
//TODO handle possible failures!
if (useDepth)
{
mDepthGen.GetMetaData(depthMD);
nXRes = depthMD.XRes();
nYRes = depthMD.YRes();
pDepth = depthMD.Data();
if (useHistogram)
{
calcHist();
// rewind the pointer
pDepth = depthMD.Data();
}
}
if (useScene)
{
mUserGen.GetUserPixels(0, sceneMD);
nXRes = sceneMD.XRes();
nYRes = sceneMD.YRes();
pLabels = sceneMD.Data();
}
}
// Updates to the latest image obtained from the Kinect
int kinectUpdate(void)
{
XnStatus nRetVal = context.WaitAndUpdateAll();
g_image.GetMetaData(g_imageMD);
//nRetVal = context.WaitOneUpdateAll(depth);
depth.GetMetaData(depthMD);
return nRetVal;
}
bool getImageCoordinatesForDepthPixel(int x, int y, int& imageX, int& imageY)
{
if (!g_Depth.IsValid())
return false; // no depth
if (!g_Image.IsValid())
return false; // no image
if (!g_Depth.IsCapabilitySupported(XN_CAPABILITY_ALTERNATIVE_VIEW_POINT))
return false;
XnUInt32 altX;
XnUInt32 altY;
if (XN_STATUS_OK != g_Depth.GetAlternativeViewPointCap().GetPixelCoordinatesInViewPoint(g_Image, x, y, altX, altY))
return false;
imageX = (int)altX;
imageY = (int)altY;
return true;
}
void closeDevice()
{
g_Player.Release();
g_Device.Release();
g_Depth.Release();
g_Image.Release();
g_IR.Release();
g_Audio.Release();
g_scriptNode.Release();
g_Context.Release();
}
void readFrame()
{
if (!g_Depth.IsValid() && !g_Image.IsValid() && !g_IR.IsValid() && !g_Audio.IsValid()) // @@@dded
return;
XnStatus rc = XN_STATUS_OK;
if (g_pPrimary != NULL)
{
rc = g_Context.WaitOneUpdateAll(*g_pPrimary);
}
else
{
rc = g_Context.WaitAnyUpdateAll();
}
if (rc != XN_STATUS_OK)
{
printf("Error: %s\n", xnGetStatusString(rc));
}
if (g_Depth.IsValid())
{
g_Depth.GetMetaData(g_DepthMD);
}
if (g_Image.IsValid())
{
g_Image.GetMetaData(g_ImageMD);
}
if (g_IR.IsValid())
{
g_IR.GetMetaData(g_irMD);
}
if (g_Audio.IsValid())
{
g_Audio.GetMetaData(g_AudioMD);
}
}
//----------------------------------------------------
// マウスのクリック処理
//----------------------------------------------------
void glutMouse(int button, int state, int _x, int _y){
int x = _x, y = _y;
XnPoint3D pt[2] = {{0,0,0},{0,0,0}};
// サイズが違う場合，680*480に標準化する
if(!(g_currentWindowSizeX == KINECT_IMAGE_WIDTH && g_currentWindowSizeY == KINECT_IMAGE_HEIGHT)){
x = 640 * _x / g_currentWindowSizeX;
y = 480 * _y / g_currentWindowSizeY;
}
if(state == GLUT_DOWN){
if(button == GLUT_LEFT_BUTTON){ // 左クリック
cout << "click! (" << _x << ", " << _y << ")->(" << x << ", " << y << "), depth = " << *(g_depthMD.Data() + y * KINECT_IMAGE_WIDTH + x) << endl;
pt[0].X = _x;
pt[0].Y = _y;
pt[0].Z = *(g_depthMD.Data() + y * KINECT_IMAGE_WIDTH + x);
//cout << "(_x, _y) -> (x, y) = (" << _x << ", " << _y << ") -> (" << x << ", " << y << ")" << endl;
g_depth.ConvertProjectiveToRealWorld(2, pt, pt);
cout << "change pt[0] => (" << pt[0].X << ", " << pt[0].Y << ", " << pt[0].Z << ")" << endl;
}else if(button == GLUT_RIGHT_BUTTON){ // 右クリック
cout << "click! back = (" << x << ", " << y << ") depth = " << *(g_pBackDepth + y * KINECT_IMAGE_WIDTH + x) << endl;
pt[1].X = _x;
pt[1].Y = _y;
pt[1].Z = *(g_pBackDepth + y * KINECT_IMAGE_WIDTH + x);
g_depth.ConvertProjectiveToRealWorld(2, pt, pt);
cout << "change pt[1] => (" << pt[1].X << ", " << pt[1].Y << ", " << pt[1].Z << ")" << endl;
}
//g_depth.ConvertProjectiveToRealWorld(2, pt, pt);
//cout << "change pt[0] => (" << pt[0].X << ", " << pt[0].Y << ", " << pt[0].Z << ")" << endl;
//cout << "change pt[1] => (" << pt[1].X << ", " << pt[1].Y << ", " << pt[1].Z << ")" << endl;
}
}
void glutDisplay (void){
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Setup the OpenGL viewpoint
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
SceneMetaData sceneMD;
DepthMetaData depthMD;
ImageMetaData imageMD;
g_DepthGenerator.GetMetaData(depthMD);
glOrtho(0, depthMD.XRes(), depthMD.YRes(), 0, -1.0, 1.0);
glDisable(GL_TEXTURE_2D);
//XnStatus rc = g_Context.WaitOneUpdateAll(g_DepthGenerator);
XnStatus rc = g_Context.WaitAnyUpdateAll();
CHECK_RC("Wait Data",rc);
g_DepthGenerator.GetMetaData(depthMD);
if(g_UserGenerator.IsValid())
g_UserGenerator.GetUserPixels(0, sceneMD);
g_ImageGenerator.GetMetaData(imageMD);
DrawDepthMap(depthMD, sceneMD);
DrawImage(imageMD);
glutSwapBuffers();
}//glutdisplay
static void cleanUp(){
g_motor.ChangeLED(KinectDevice::LED_RED);
svmFree();
g_motor.Close();
context.StopGeneratingAll();
g_depth.Release();
g_mockDepth.Release();
g_user.Release();
context.Release();
printf("Program end without errors\n");
fflush(stdout);
fclose(record);
}
XnStatus prepare(char useScene, char useDepth, char useImage, char useIr, char useHistogram)
{
//TODO handle possible failures! Gotcha!
if (useDepth)
{
mDepthGen.GetMetaData(depthMD);
nXRes = depthMD.XRes();
nYRes = depthMD.YRes();
pDepth = depthMD.Data();
if (useHistogram)
{
calcHist();
// rewind the pointer
pDepth = depthMD.Data();
}
}
if (useScene)
{
mUserGen.GetUserPixels(0, sceneMD);
nXRes = sceneMD.XRes();
nYRes = sceneMD.YRes();
pLabels = sceneMD.Data();
}
if (useImage)
{
mImageGen.GetMetaData(imageMD);
nXRes = imageMD.XRes();
nYRes = imageMD.YRes();
pRGB = imageMD.RGB24Data();
// HISTOGRAM?????
}
if (useIr)
{
mIrGen.GetMetaData(irMD);
nXRes = irMD.XRes();
nYRes = irMD.YRes();
pIR = irMD.Data();
// HISTOGRAM????
}
}
/*
* Class: org_OpenNI_Samples_Assistant_NativeMethods
* Method: initFromContext
* Signature: (JZZ)I
*/
JNIEXPORT jint JNICALL
Java_org_OpenNI_Samples_Assistant_NativeMethods_initFromContext
(JNIEnv *env, jclass cls, jlong pContext, jboolean _hasUserGen, jboolean _hasDepthGen)
{
LOGD("init_start");
hasUserGen = _hasUserGen;
hasDepthGen = _hasDepthGen;
mContext = new Context((XnContext*) pContext);
if (!(hasUserGen || hasDepthGen))
return XN_STATUS_BAD_PARAM;
int rc;
if (hasUserGen)
{
rc = mContext->FindExistingNode(XN_NODE_TYPE_USER, mUserGen);
if (rc != XN_STATUS_OK)
{
//TODO log&retval
printf("No user node exists!");
return 1;
}
mUserGen.GetUserPixels(0, sceneMD);
}
if (hasDepthGen)
{
rc = mContext->FindExistingNode(XN_NODE_TYPE_DEPTH, mDepthGen);
if (rc != XN_STATUS_OK)
{
//TODO log&retval
printf("No depth node exists! Check your XML.");
return 1;
}
mDepthGen.GetMetaData(depthMD);
}
initGraphics();
LOGD("init_end");
return XN_STATUS_OK;
}
void takePhoto() {
static int index = 1;
char fname[256] = {0,};
sprintf(fname, "kinect%03d.txt", index++);
g_depth.GetMetaData(g_depthMD);
g_image.GetMetaData(g_imageMD);
int const nx = g_depthMD.XRes();
int const ny = g_depthMD.YRes();
assert(nx == g_imageMD.XRes());
assert(ny == g_imageMD.YRes());
const XnDepthPixel* pDepth = g_depthMD.Data();
const XnUInt8* pImage = g_imageMD.Data();
FILE * file = fopen(fname, "wb");
fprintf(file, "%d\n%d\n\n", nx, ny);
for (int y = 0, di = 0, ri = 0, gi = 1, bi = 2; y < ny; y++) {
for (int x = 0; x < nx; x++, di++, ri += 3, gi += 3, bi += 3) {
int const r = pImage[ri];
int const g = pImage[gi];
int const b = pImage[bi];
int const d = pDepth[di];
assert(r >= 0);
assert(g >= 0);
assert(b >= 0);
assert(d >= 0);
assert(r <= 0xFF);
assert(g <= 0xFF);
assert(b <= 0xFF);
assert(d <= 0xFFFF);
fprintf(file, "%3d %3d %3d %5d\n", r, g, b, d);
}
fprintf(file, "\n");
}
fflush(file);
fclose(file);
}
/*
* Class: org_OpenNI_Samples_Assistant_NativeMethods
* Method: dispose
* Signature: ()I
*/
JNIEXPORT jint JNICALL
Java_org_OpenNI_Samples_Assistant_NativeMethods_dispose (JNIEnv *, jclass)
{
LOGD("dispose_start");
disposeGraphics();
mUserGen.Release();
hasUserGen = 0;
mDepthGen.Release();
hasDepthGen = 0;
mContext->Release();
delete mContext;
mContext = 0;
LOGD("dispose_end");
return XN_STATUS_OK;
}
/*
* Function: run
*
* Starts and continues generating data from the Kinect.
* A loop runs and updates data whenever new data is available from one of the Kinect
* devices, and then the data is processed to check for patient movement.
* The loop is controlled by the "quit" global boolean, which is set to false by the
* signal handler "stop()"
*/
void KinectMonitor::run() {
XnStatus status;
SceneMetaData scene;
DepthMetaData depth;
// Start the device
status = context.StartGeneratingAll();
// Running loop
while( !quit ) {
// Wait for any new incoming data
context.WaitOneUpdateAll(depthGenerator);
// Mark the new frame
xnFPSMarkFrame(&xnFPS);
// Get the depth data from the device
depthGenerator.GetMetaData(depth);
// Get the recognized users
XnUInt16 numUsers = 15;
XnUserID users[numUsers];
userGenerator.GetUsers(users, numUsers);
// Only track the patient if they are alone
if( numUsers != 1) continue;
// Get the user data
userGenerator.GetUserPixels(users[0], scene);
// Update patient position
previous = current;
current = getPosition(users[0]);
// Raise alerts based on the patient's state and position
if( previous != current ) {
if( current == TURNED && out == false ) {
// Patient is turned
printf("Patient getting out of bed.\n");
} else if( out && bedSet ) {
printf("Patient is out of bed.\n");
}
}
}
}
// Set up OpenNI to obtain 8-bit mono images from the Kinect's RGB camera
int kinectInit(void)
{
XnStatus nRetVal = XN_STATUS_OK;
ScriptNode scriptNode;
EnumerationErrors errors;
printf("Reading config from: '%s'\n", SAMPLE_XML_PATH_LOCAL);
nRetVal = context.InitFromXmlFile(SAMPLE_XML_PATH_LOCAL, scriptNode, &errors);
nRetVal = context.FindExistingNode(XN_NODE_TYPE_IMAGE, g_image);
//g_image.SetPixelFormat(XN_PIXEL_FORMAT_GRAYSCALE_8_BIT);
g_image.SetPixelFormat(XN_PIXEL_FORMAT_RGB24);
g_image.GetMetaData(g_imageMD);
nRetVal = context.FindExistingNode(XN_NODE_TYPE_DEPTH, depth);
depth.GetMetaData(depthMD);
// nRetVal = depth.GetAlternativeViewPointCap().SetViewPoint(g_image);
//nRetVal = depth.GetFrameSyncCap().FrameSyncWith(g_image);
return nRetVal;
}
XnStatus Init_Kinect(EventOutSFNode* skltn,EventOutSFNode* hnz,EventOutSFNode* flr){
XnStatus rc=XN_STATUS_OK;
EnumerationErrors errors;
DepthMetaData g_depthMD;
ImageMetaData g_imageMD;
rc = g_context.InitFromXmlFile(SAMPLE_XML_PATH, &errors);
CHECK_RC(rc, "InitFromXml");
rc = g_context.FindExistingNode(XN_NODE_TYPE_DEPTH, g_depth);
CHECK_RC(rc,"XN_NODE_TYPE_DEPTH");
rc = g_context.FindExistingNode(XN_NODE_TYPE_IMAGE, g_image);
CHECK_RC(rc,"XN_NODE_TYPE_IMAGE");
rc= g_context.FindExistingNode(XN_NODE_TYPE_USER,g_user);
CHECK_RC(rc,"XN_NODE_TYPE_USER");
rc=g_context.FindExistingNode(XN_NODE_TYPE_SCENE,g_scene);
CHECK_RC(rc,"XN_NODE_TYPE_SCENE");
rc=g_context.FindExistingNode(XN_NODE_TYPE_HANDS,g_hands);
CHECK_RC(rc,"XN_NODE_TYPE_HANDS");
rc=g_context.FindExistingNode(XN_NODE_TYPE_GESTURE,g_gesture);
CHECK_RC(rc,"XN_NODE_TYPE_GESTURE");
g_depth.GetMetaData(g_depthMD);
g_fps=g_depthMD.FPS();
g_image.GetMetaData(g_imageMD);
rc=init_skeleton();
CHECK_RC(rc,"INIT SKELETON");
rc=init_hands();
CHECK_RC(rc,"INIT HANDS");
pix_w=g_depthMD.FullXRes();
pix_h=g_depthMD.FullYRes();
if(pix_h==0||pix_w==0){return XN_STATUS_ERROR;}
g_skltn=skltn;
g_hnz=hnz;
g_flr=flr;
if(NULL==g_skltn||NULL==g_hands||NULL==g_flr)return XN_STATUS_ERROR;
isInit=true;
return rc;
}
//--------------------------------------------------------------
void testApp::setup(){
XnStatus rc;
EnumerationErrors errors;
rc = g_context.InitFromXmlFile(SAMPLE_XML_PATH, g_scriptNode, &errors);
if (rc == XN_STATUS_NO_NODE_PRESENT)
{
XnChar strError[1024];
errors.ToString(strError, 1024);
printf("%s\n", strError);
return ;
}
else if (rc != XN_STATUS_OK)
{
printf("Open failed: %s\n", xnGetStatusString(rc));
return;
}
rc = g_context.FindExistingNode(XN_NODE_TYPE_DEPTH, g_depth);
if (rc != XN_STATUS_OK)
{
printf("No depth node exists! Check your XML.");
return;
}
g_depth.GetMetaData(g_depthMD);
// Texture map init
g_nTexMapX = (((unsigned short)(g_depthMD.FullXRes()-1) / 512) + 1) * 512;
g_nTexMapY = (((unsigned short)(g_depthMD.FullYRes()-1) / 512) + 1) * 512;
g_pTexMap = (XnRGB24Pixel*)malloc(g_nTexMapX * g_nTexMapY * sizeof(XnRGB24Pixel));
std::cout << " w:" << g_depthMD.FullXRes() << " h:" << g_depthMD.FullYRes() << std::endl;
pixels = (unsigned char*)malloc(640*480*3*sizeof(unsigned char));
tex.allocate(640, 480, GL_RGB);
}
