void ScheinrieseApp::handleKinect()
{
if (!hasKinect) {
return;
}
if( mKinectTilt != mKinect.getTilt() ) {
mKinect.setTilt( mKinectTilt );
}
if( mKinect.checkNewDepthFrame() ) {
mDepthTexture = mKinect.getDepthImage();
}
if( mKinect.checkNewVideoFrame() ) {
mColorTexture = mKinect.getVideoImage();
}
/* debug view */
if (mColorTexture && !mDebugViewColor) {
mGui->addLabel("COLOR");
mDebugViewColor = mGui->addParam("COLOR", &mColorTexture);
mDebugViewColor->var = &mColorTexture;
console() << "color" << endl;
}
if (mDepthTexture && !mDebugViewDepth) {
mGui->addLabel("DEPTH");
mDebugViewDepth = mGui->addParam("DEPTH", &mDepthTexture);
mDebugViewDepth->var = &mDepthTexture;
console() << "depth" << endl;
}
}
void ScheinrieseApp::setup()
{
// GUI
mGui = new SimpleGUI(this);
mGui->addColumn();
mGui->addLabel("CONTROLS");
mGui->addParam("Threshold", &mThreshold, 0, 255, 127);
mGui->addParam("Blur", &mBlur, 1, 20, 1);
mGui->addParam("Tilt", &mKinectTilt, -30, 30, 0);
mGui->addColumn();
mGui->addLabel("DEBUG VIEW");
mGui->addParam("Show Debug", &mShowDebug, true);
// mGui->addButton("Show Debug")->registerClick(this, &ScheinrieseApp::showDebug);
mGui->load(getResourcePath(RES_SETTINGS));
mGui->setEnabled(false);
mBlur = 1;
mThreshold = 127;
mShowDebug = true;
// KINECT
hasKinect = false;
console() << "### INFO: There are " << Kinect::getNumDevices() << " Kinects connected." << endl;
if (Kinect::getNumDevices() >= 1) {
mKinect = Kinect( Kinect::Device() );
mKinect.setTilt(mKinectTilt);
hasKinect = true;
}
}
static void openflkinect_set_tilt(value ref, value degrees)
{
val_check_kind(ref, k_Kinect);
val_check(degrees, int);
Kinect* k = static_cast<Kinect*>(val_data(ref));
k->setTilt(val_int(degrees));
}
void kinectPointCloudApp::update()
{
if( mKinect.checkNewDepthFrame() )
mDepthTexture = mKinect.getDepthImage();
// This sample does not use the color data
//if( mKinect.checkNewVideoFrame() )
// mColorTexture = mKinect.getVideoImage();
if( mKinectTilt != mKinect.getTilt() )
mKinect.setTilt( mKinectTilt );
mEye = Vec3f( 0.0f, 0.0f, mCameraDistance );
mCam.lookAt( mEye, mCenter, mUp );
gl::setMatrices( mCam );
}
void kinectSkelApp::update()
{
if( mKinect.checkNewDepthFrame() )
{
//mDepthTexture = mKinect.getDepthImage();
depthSurf = Surface8u(mKinect.getDepthImage());
cv::Mat input( toOcv( depthSurf ) );
cv::Mat thr1, thr2, dilated, thr3(640, 480, CV_8UC1), dist(640, 480, CV_32FC1), distC, distLapl(640, 480, CV_8UC1),
distLapl00(640, 480, CV_8UC1), distLapl45(640, 480, CV_8UC1), distLapl90(640, 480, CV_8UC1), distLapl135(640, 480, CV_8UC1), distLaplC, distThresh, distThreshC, distBlur, distFinal, distFinalC;
//cv::medianBlur( input, output, 100 );
// cv::Sobel( input, output, CV_8U, 0, 1 );
cv::threshold( input, thr1, mLo * 255.0f, 255, CV_THRESH_TOZERO );
cv::threshold( thr1, thr2, mHi * 255.0f, 255, CV_THRESH_TOZERO_INV );
//cv::dilate( thr2, dilated, cv::Mat(mDilateSize, mDilateSize, CV_8UC1), cv::Point(-1,-1), mDilateIter );
cv::morphologyEx(thr2, dilated, cv::MORPH_CLOSE, cv::Mat(mDilateSize, mDilateSize, CV_8UC1), cv::Point(-1,-1), mDilateIter);
cv::threshold( dilated, thr3, mLo * 255.0f, 255, CV_THRESH_BINARY );
cv::Mat thr3bin( toOcv( Channel8u( fromOcv( thr3 ) ) ) );
cv::distanceTransform(thr3bin, dist, CV_DIST_L2, CV_DIST_MASK_5);
//cv::cvtColor(dist, distC, CV_GRAY2RGB);
dist.convertTo(distC, CV_8UC1, 1.0f, .0f);
//cv::Laplacian(distC, distLapl, 8, 3);
// cv::Sobel(distC, distLapl, 8, 1, 1);
cv::filter2D(distC, distLapl00, 8, kern00, cv::Point(-1, -1), 0);
cv::filter2D(distC, distLapl45, 8, kern45, cv::Point(-1, -1), 0);
cv::filter2D(distC, distLapl90, 8, kern90, cv::Point(-1, -1), 0);
cv::filter2D(distC, distLapl135, 8, kern135, cv::Point(-1, -1), 0);
distLapl = distLapl.t();
int index;
for(int x = 0; x < 640; x++)
{
for(int y = 0; y < 480; y++)
{
index = y * 640 + x;
float smax = getMax(distLapl00.data[index], distLapl45.data[index], distLapl90.data[index], distLapl135.data[index]);
distLapl.data[index] = smax > 0 ? smax : 0;
}
}
//distLapl = distLapl.t();
distLapl.convertTo(distLaplC, CV_8UC1, 1.0f, .0f);
cv::threshold(distLaplC, distThresh, mSkelThresh, 255, CV_THRESH_BINARY);
// cv::adaptiveThreshold(distLaplC, distThresh, 255, cv::ADAPTIVE_THRESH_GAUSSIAN_C, CV_THRESH_BINARY, 7, 0);
distThresh.convertTo(distThreshC, CV_8UC1, 1.0f, .0f);
cv::GaussianBlur(distThreshC, distBlur, cv::Size(5, 5), 3, 0);
cv::adaptiveThreshold(distBlur, distFinal, 255, cv::ADAPTIVE_THRESH_GAUSSIAN_C, CV_THRESH_BINARY, 7, 0);
//cv::threshold(distBlur, distFinal, mSkelThresh, 255, CV_THRESH_TOZERO);
//cv::medianBlur( distThreshC, distFinal, 3 );
distFinal.convertTo(distFinalC, CV_8UC1, 1.0f, .0f);
Surface8u surfDist(fromOcv(distThreshC));
Surface8u surfDistRaw(fromOcv(distC));
mDepthTexture = gl::Texture( surfDist );
mColorTexture = gl::Texture( surfDistRaw );
}
// if( mKinect.checkNewColorFrame() )
// mColorTexture = mKinect.getColorImage();
if( mKinectTilt != mKinect.getTilt() )
mKinect.setTilt( mKinectTilt );
// console() << "Accel: " << kinect.getAccel() << std::endl;
}
void HandTrackingApp::update()
{
if( mKinect.checkNewDepthFrame() ){
ImageSourceRef depthImage = mKinect.getDepthImage();
// make a texture to display
mDepthTexture = depthImage;
// make a surface for opencv
mDepthSurface = depthImage;
if(mDepthSurface){
// once the surface is avalable pass it to opencv
// had trouble here with bit depth. surface comes in full color, needed to crush it down
cv::Mat input( toOcv( Channel8u( mDepthSurface ) ) ), blurred, thresholded, thresholded2, output;
cv::blur(input, blurred, cv::Size(10,10));
// make two thresholded images one to display and one
// to pass to find contours since its process alters the image
cv::threshold( blurred, thresholded, mThreshold, 255, CV_THRESH_BINARY);
cv::threshold( blurred, thresholded2, mThreshold, 255, CV_THRESH_BINARY);
// 2d vector to store the found contours
vector<vector<cv::Point> > contours;
// find em
cv::findContours(thresholded, contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE);
// convert theshold image to color for output
// so we can draw blobs on it
cv::cvtColor( thresholded2, output, CV_GRAY2RGB );
// loop the stored contours
for (vector<vector<cv::Point> >::iterator it=contours.begin() ; it < contours.end(); it++ ){
// center abd radius for current blob
cv::Point2f center;
float radius;
// convert the cuntour point to a matrix
vector<cv::Point> pts = *it;
cv::Mat pointsMatrix = cv::Mat(pts);
// pass to min enclosing circle to make the blob
cv::minEnclosingCircle(pointsMatrix, center, radius);
cv::Scalar color( 0, 255, 0 );
if (radius > mBlobMin && radius < mBlobMax) {
// draw the blob if it's in range
cv::circle(output, center, radius, color);
//update the target position
mTargetPosition.x = 640 - center.x;
mTargetPosition.y = center.y;
mTargetPosition.z = 0;
}
}
mCvTexture = gl::Texture( fromOcv( output ) );
}
}
if( mKinect.checkNewColorFrame() )
mColorTexture = mKinect.getColorImage();
if( mKinectTilt != mKinect.getTilt() )
mKinect.setTilt( mKinectTilt );
}