利用KINECT+OPENCV检测手势的演示程序

// KinectOpenCVTest.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

#include <stdlib.h>
#include <iostream>
#include <string>
#include <XnCppWrapper.h>
#include <opencv2/opencv.hpp>

//#include "opencv/cv.h"
//#include "opencv/highgui.h"
using namespace std;
using namespace cv;

#define SAMPLE_XML_PATH "../../Data/SamplesConfig.xml"

//全局模板轮廓
vector<vector<Point>> g_TemplateContours;

//模板个数
int g_handTNum = 6;

void CheckOpenNIError( XnStatus eResult, string sStatus )
{
if( eResult != XN_STATUS_OK )
{
cerr << sStatus << " Error: " << xnGetStatusString( eResult ) << endl;
return;
}
}

//载入模板的轮廓
void init_hand_template()
{
//int handTNum = 10;
string temp = "HandTemplate/";

int i = 0;

for(i=0; i<g_handTNum; i++)
{
stringstream ss;
ss << i << ".bmp";

string fileName = temp + ss.str();

//读入灰度图像
Mat src = imread(fileName, 0);

if(!src.data)
{
printf("未找到文件: %s/n", fileName);
continue;
}

vector<vector<Point>> contours;
vector<Vec4i> hierarchy;

findContours(src, contours, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE);
//findContours(src, contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE);

g_TemplateContours.push_back(contours[0]);
}
}

//模板匹配手
int hand_template_match(Mat& hand)
{
//int handTNum = 10;
int minId = -1;
double minHu = 1;

double hu;
int method = CV_CONTOURS_MATCH_I1;

//match_num = 0;

for(int i=0; i<g_handTNum; i++){

Mat temp(g_TemplateContours.at(i));
hu = matchShapes(temp, hand, method, 0);

//找到hu矩最小的模板
if(hu < minHu){
minHu = hu;
minId = i;
}

//printf("%f ", hu);
}

//显示匹配结果
int Hmatch_value = 25;//模板匹配系数

if(minHu<((double)Hmatch_value)/100)
return minId;
else
return -1;
}

void findHand(Mat& src, Mat& dst)
{
vector<vector<Point>> contours;
vector<Vec4i> hierarchy;

//找到外部轮廓
//findContours(src, contours, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE);
findContours(src, contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE); //CV_CHAIN_APPROX_NONE);
//findContours(src, contours, CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE);

Mat dst_r = Mat::zeros(src.rows, src.cols, CV_8UC3);
dst_r.copyTo(dst);

// iterate through all the top-level contours,
// draw each connected component with its own random color
int idx = 0;
double maxArea = 0.0;
int maxId = -1;

for(unsigned int i = 0; i<contours.size(); i++)
{
Mat temp(contours.at(i));
double area = fabs(contourArea(temp));
if(area > maxArea)
{
maxId = i;
maxArea = area;
}
}

//for( ; idx >= 0; idx = hierarchy[idx][0] )
//{
//	//Scalar color( rand()&255, rand()&255, rand()&255 );
//	//drawContours(dst, contours, idx, color, CV_FILLED, 8, hierarchy );

//	double area = contourArea(contours.at(idx));
//	if(area > maxArea)
//	{
//		maxId = idx;
//		maxArea = area;
//	}
//}

//显示最大轮廓外形，以及最佳匹配的模板ID
if(contours.size() > 0)
{
Scalar color(0, 255, 255 );
drawContours(dst, contours, maxId, color);

Mat hand(contours.at(maxId));
int value = hand_template_match(hand);

if(value >= 0)
{
Scalar templateColor(255, 0, 255 );
drawContours(dst, g_TemplateContours, value, templateColor);

printf("Match %d /r/n", value);

stringstream ss;
ss << "Match " << value;
string text = ss.str();
putText(dst, text, Point(300, 30), FONT_HERSHEY_SIMPLEX, 1.0, templateColor);
}
}
}

int HandDetect()
{
init_hand_template();

XnStatus eResult = XN_STATUS_OK;

// 1. initial val
xn::DepthMetaData m_DepthMD;
xn::ImageMetaData m_ImageMD;

// for opencv Mat
Mat  m_depth16u( 480,640,CV_16UC1);
Mat  m_rgb8u( 480,640,CV_8UC3);
Mat  m_DepthShow( 480,640,CV_8UC1);
Mat  m_ImageShow( 480,640,CV_8UC3);

Mat  m_DepthThreshShow( 480,640,CV_8UC1);
Mat  m_HandShow( 480,640,CV_8UC3);

//cvNamedWindow("depth");
//cvNamedWindow("image");
//cvNamedWindow("depthThresh");

char key=0;

// 2. initial context
xn::Context mContext;

eResult = mContext.Init();

//xn::EnumerationErrors errors;
//eResult = mContext.InitFromXmlFile(SAMPLE_XML_PATH, &errors);

CheckOpenNIError( eResult, "initialize context" );

//Set mirror
mContext.SetGlobalMirror(!mContext.GetGlobalMirror());

// 3. create depth generator
xn::DepthGenerator mDepthGenerator;
eResult = mDepthGenerator.Create( mContext );
CheckOpenNIError( eResult, "Create depth generator" );

// 4. create image generator
xn::ImageGenerator mImageGenerator;
eResult = mImageGenerator.Create( mContext );
CheckOpenNIError( eResult, "Create image generator" );

// 5. set map mode
XnMapOutputMode mapMode;
mapMode.nXRes = 640;
mapMode.nYRes = 480;
mapMode.nFPS = 30;
eResult = mDepthGenerator.SetMapOutputMode( mapMode );
eResult = mImageGenerator.SetMapOutputMode( mapMode );

//由于 Kinect 的深度摄像机和彩色摄像机是在不同的位置，而且镜头本身的参数也不完全相同，所以两个摄像机所取得的画面会有些微的差异
//将深度摄像机的视角调整到RGB摄像机位置
// 6. correct view port
mDepthGenerator.GetAlternativeViewPointCap().SetViewPoint( mImageGenerator );

// 7. start generate data
eResult = mContext.StartGeneratingAll();

// 8. read data
eResult = mContext.WaitNoneUpdateAll();
while( (key!=27) && !(eResult = mContext.WaitNoneUpdateAll( ))  )
{
// 9a. get the depth map
mDepthGenerator.GetMetaData(m_DepthMD);
memcpy(m_depth16u.data,m_DepthMD.Data(), 640*480*2);

// 9b. get the image map
mImageGenerator.GetMetaData(m_ImageMD);
memcpy(m_rgb8u.data,m_ImageMD.Data(),640*480*3);

//将未知深度转为白色，便于在OPENCV中分析
XnDepthPixel* pDepth = (XnDepthPixel*)m_depth16u.data;

for (XnUInt y = 0; y < m_DepthMD.YRes(); ++y)
{
for (XnUInt x = 0; x < m_DepthMD.XRes(); ++x, ++pDepth)
{
if (*pDepth == 0)
{
*pDepth = 0xFFFF;
}
}
}

//由于OpenNI获得的深度图片是16位无符号整数，而OpenCV显示的是8位的，所以要作转换。

//将距离转换为灰度值（0-2550mm 转换到 0-255），例如1000毫米转换为 1000×255/2550 = 100
//m_depth16u.convertTo(m_DepthShow,CV_8U, 255/2096.0);
m_depth16u.convertTo(m_DepthShow,CV_8U, 255/2550.0);

//可以考虑根据数据缩减图像大小到有效范围

//在此对灰度图像进行处理，平滑和去噪声
//medianBlur(m_DepthShow, m_DepthThreshShow, 3);
//m_DepthThreshShow.copyTo(m_DepthShow);
//medianBlur(m_DepthThreshShow, m_DepthShow, 3);
blur(m_DepthShow, m_DepthThreshShow, Size(3, 3));
//m_DepthThreshShow.copyTo(m_DepthShow);
blur(m_DepthThreshShow, m_DepthShow, Size(3, 3));

Mat  pyrTemp( 240,320,CV_8UC1);
pyrDown(m_DepthShow, pyrTemp);
pyrUp(pyrTemp, m_DepthShow);

//dilate(m_DepthShow, m_DepthThreshShow, Mat(), Point(-1,-1), 3);
//erode(m_DepthThreshShow, m_DepthShow, Mat(), Point(-1,-1), 3);

//for(int i = 0; i < m_depth16u.rows; i++)
//	for(int j = 0; j < m_depth16u.cols; j++)
//	{
//		if(m_depth16u.at<unsigned short>(i,j) < 1)
//			m_depth16u.at<unsigned short>(i,j) == 0xFFFF;

//		//m_depth16u.at<double>(i,j)=1./(i+j+1);
//	}

//RGB和BGR在内存对应的位置序列不同，所以也要转换。
cvtColor(m_rgb8u,m_ImageShow,CV_RGB2BGR);

//imshow("depth", m_DepthShow);
//imshow("image", m_ImageShow);

double  thd_max = 0xFFFF;
double  thd_val = 100.0;

//反转黑白图像，以便找到最大外部轮廓
//threshold(m_DepthShow, m_DepthThreshShow, thd_val, thd_max, CV_THRESH_BINARY);
threshold(m_DepthShow, m_DepthThreshShow, thd_val, thd_max, CV_THRESH_BINARY_INV);
imshow("depthThresh", m_DepthThreshShow);

findHand(m_DepthThreshShow, m_HandShow);
imshow( "Hand", m_HandShow );

key=cvWaitKey(20);
}

// 10. stop
mContext.StopGeneratingAll();
mContext.Shutdown();

return 0;
}

int _tmain(int argc, _TCHAR* argv[])
{
HandDetect();
}