Kinect+OpenNI学习笔记之11(OpenNI驱动kinect手势相关的类的设计)

　　前言

　　本文所设计的类主要是和人体的手部打交道的，与人体的检测，姿势校正，骨架跟踪没有关系，所以本次类的设计中是在前面的OpenNI+Kinect系列博文基础上去掉那些与手势无关的驱动，较小代码量负担。类中保留下来有手势识别，手部跟踪，以及手部跟踪的轨迹和多个手部的位置坐标等信息。本类的设计也开始慢慢遵循一些C/C++编程规范，这里采用的是google的编程规范。

　　本文测试设计出的类的功能是与博文不需要骨骼跟踪的人体多个手部分割 一样，进行人体多个手部跟踪和分割。

　　开发环境：开发环境：QtCreator2.5.1+OpenNI1.5.4.0+Qt4.8.2+OpenCV2.4.2

 

　　Google编程规范节选

　　类的设计的规范性，首先是遵循一定的编程风格，这里本人采用的是google C++编程风格。Google编程规范具体内容可以参考网页：Google C++ Style Guide。 这次类的设计是在前面的博文使用OpenNI自带的类进行简单手势识别 和博文不需要骨骼跟踪的人体多个手部分割 的基础上从下面几个地方做了编程风格规范：

　　1.  将类的设计分开为头文件和源文件，前面类的设计是在一个cpp文件中。分开设计的目的是使代码看起来结构更加清晰。

　　2. 在类中使用特定的声明次序，即public在前，随后依次为protected, private.且在其内部是成员函数在成员变量之前。比如在public的内部，一般的声明次序为：typedef和enums,常量，构造函数，析构函数，成员函数(包括静态成员函数)，数据成员(包括静态数据成员)。

　　3. 类中的函数体要尽量短小，紧凑，功能单一。

　　4. 类的成员函数命名以大写字母开头，每个单词首字母大写，没有下划线。内联函数命名除外。

　　5. 类的成员变量名一徇小写，单词间以下划线相还，并以下划线结尾。

　　6. Typedef类型命名时，其类型名字每个单词以大写字母开头，不包含下划线。

 

   　openNI知识点总结

　　从OpenNI源码的下面2句代码中可以看出，XnUserID是unsigned int类型。

typedef    unsigned int              XnUInt32;

 

typedef XnUInt32 XnUserID;

　　openni有些回调函数中会有传入参数类型为XnUserID的数据，比如在本文讲类的设计中，XnUserID类型就代表检测到的不同手部的id号，因为该id理论上是用来表明不同的手部的，因此当检测到新的手部时，系统中XnUserID类型对应变量将会加1。总的来看，XnUserID类型对应的变量值一直在递增，刚刚上面有讲到XnUserID是unsigned int类型的，所以其表示的范围能力可以是很大，即使由于视频中出现有很多的误检导致其值增加很多，这还是足够用了的。误检主要是某些情况下，http://fzl.qqq80.com 人的一只手由于运动速度过快或者其背景的干扰，在手势检测过程中有可能同时被当做是几十只手，这时候手部的id值就会一下子增加很多。所以在程序的后续的跟踪过程中，id值(通过输出到后台来观察)有可能很大。这时如果要遍历id的话，会影响程序的速度和内存开销。但是这也没有办法，因为我们的工作是基于OpenNI的手部跟踪的基础上的，只能依靠手部跟踪的性能了。

　　虽然说手部的id值会很大，但是我们在一个视野中出现的手的个数并不是特别多，顶多几十只手。所以在程序中如果要给不同的手部不同的颜色跟踪，或者对不同的手部都采用不同的掩膜区域，此时设置为颜色的个数和掩膜区域的个数就不需要最大的id值那么大了，因为虽然id值高，但是有些手部退出了视野，其内存中对应存的id那一项被删掉了，实际的手的数目不会特别大。因此在程序中，我们可以先不考虑id的最大值，而设置一个手部最大的个数，比如说20。然后用id值对最大个数20取掩膜来进行遍历。如果程序中不用它来求默认个数的掩膜的话，随着id值的增加，程序运行时有可能会连续出现下面3个错误：

　　

　　

　　 

　　为了解决这个错误都弄了大半天了。其原因是程序中id的值一直在增加，且人为修改它的值起不到任何效果，它是由OpenNI内部决定的。

 

 

　　C/C++知识点总结

　　define和typedef使用时恰恰相反，简单一点来理解：define是将它后面的第1个来代替第2个使用，而typedef是将它后面的第2个来代替第1个使用。

 

　　类的源码

　　copennihand.h:

 

#ifndef COpenniHand_H

#define COpenniHand_H

http://liebiao.ttplay8.cn

#include <XnCppWrapper.h>

#include <iostream>

#include <vector>

#include <map>

 

using namespace xn;

using namespace std;

 

class COpenniHand

{

public:

    COpenniHand();

    ~COpenniHand();

 

    /*OpenNI的内部初始化，属性设置*/

    bool Initial();

 

    /*启动OpenNI读取Kinect数据*/

    bool Start();

 

    /*更新OpenNI读取到的数据*/

    bool UpdateData();

 

    /*得到色彩图像的node*/

    ImageGenerator& getImageGenerator();

 

    /*得到深度图像的node*/

    DepthGenerator& getDepthGenerator();

 

    /*得到手势姿势的node*/

    GestureGenerator& getGestureGenerator();

 

    /*得到手部的node*/

    HandsGenerator& getHandGenerator();

    DepthMetaData depth_metadata_;   //返回深度图像数据

    ImageMetaData image_metadata_;   //返回彩色图像数据

    std::map<XnUserID, XnPoint3D> hand_points_;  //为了存储不同手的实时点而设置的

    std::map< XnUserID, vector<XnPoint3D> > hands_track_points_; //为了绘画后面不同手部的跟踪轨迹而设定的

 

private:

    /*该函数返回真代表出现了错误，返回假代表正确*/

    bool CheckError(const char* error);

 

    /*表示某个手势动作已经完成检测的回调函数*/

    static void XN_CALLBACK_TYPE  CBGestureRecognized(xn::GestureGenerator &generator, const XnChar *strGesture,

                                                      const XnPoint3D *pIDPosition, const XnPoint3D *pEndPosition,

                                                      void *pCookie);

 

    /*表示检测到某个手势开始的回调函数*/

    static void XN_CALLBACK_TYPE CBGestureProgress(xn::GestureGenerator &generator, const XnChar *strGesture,

                                                   const XnPoint3D *pPosition, XnFloat fProgress, void *pCookie);

 

    /*手部开始建立的回调函数*/

    static void XN_CALLBACK_TYPE HandCreate(HandsGenerator& rHands, XnUserID xUID, const XnPoint3D* pPosition,

                                            XnFloat fTime, void* pCookie);

 

    /*手部开始更新的回调函数*/

    static void XN_CALLBACK_TYPE HandUpdate(HandsGenerator& rHands, XnUserID xUID, const XnPoint3D* pPosition, XnFloat fTime,

                                            void* pCookie);

 

    /*手部销毁的回调函数*/

    static void XN_CALLBACK_TYPE HandDestroy(HandsGenerator& rHands, XnUserID xUID, XnFloat fTime, void* pCookie);

 

    XnStatus status_;

    Context context_;

    XnMapOutputMode xmode_;

    ImageGenerator  image_generator_;

    DepthGenerator  depth_generator_;

    GestureGenerator gesture_generator_;

    HandsGenerator  hand_generator_;

};

 

#endif // COpenniHand_H

 

 

　　copennihand.cpp:

 

#include "copennihand.h"

#include <XnCppWrapper.h>

#include <iostream>

#include <map>

 

using namespace xn;

using namespace std;

 

COpenniHand::COpenniHand()

{

}

 

COpenniHand::~COpenniHand()

{

}

 

bool COpenniHand::Initial()

{

    status_ = context_.Init();

    if(CheckError("Context initial failed!")) {

        return false;

    }

 

    context_.SetGlobalMirror(true);//设置镜像

    xmode_.nXRes = 640;

    xmode_.nYRes = 480;

    xmode_.nFPS = 30;

 

    //产生颜色node

    status_ = image_generator_.Create(context_);

    if(CheckError("Create image generator  error!")) {

        return false;

    }

 

    //设置颜色图片输出模式

    status_ = image_generator_.SetMapOutputMode(xmode_);

    if(CheckError("SetMapOutputMdoe error!")) {

        return false;

    }

 

    //产生深度node

    status_ = depth_generator_.Create(context_);

    if(CheckError("Create depth generator  error!")) {

        return false;

    }

 

    //设置深度图片输出模式

    status_ = depth_generator_.SetMapOutputMode(xmode_);

    if(CheckError("SetMapOutputMdoe error!")) {

        return false;

    }

 

    //产生手势node

    status_ = gesture_generator_.Create(context_);

    if(CheckError("Create gesture generator error!")) {

        return false;

    }

 

    /*添加手势识别的种类*/

    gesture_generator_.AddGesture("Wave", NULL);

    gesture_generator_.AddGesture("click", NULL);

    gesture_generator_.AddGesture("RaiseHand", NULL);

    gesture_generator_.AddGesture("MovingHand", NULL);

 

    //产生手部的node

    status_ = hand_generator_.Create(context_);

    if(CheckError("Create hand generaotr error!")) {

        return false;

    }

 

    //视角校正

    status_ = depth_generator_.GetAlternativeViewPointCap().SetViewPoint(image_generator_);

    if(CheckError("Can't set the alternative view point on depth generator!")) {

        return false;

    }

 

    //设置与手势有关的回调函数

    XnCallbackHandle gesture_cb;

    gesture_generator_.RegisterGestureCallbacks(CBGestureRecognized, CBGestureProgress, this, gesture_cb);

 

    //设置于手部有关的回调函数

    XnCallbackHandle hands_cb;

    hand_generator_.RegisterHandCallbacks(HandCreate, HandUpdate, HandDestroy, this, hands_cb);

 

    return true;

}

 

bool COpenniHand::Start()

{

    status_ = context_.StartGeneratingAll();

    if(CheckError("Start generating error!")) {

        return false;

    }

    return true;

}

 

bool COpenniHand::UpdateData()

{

    status_ = context_.WaitNoneUpdateAll();

    if(CheckError("Update date error!")) {

        return false;

    }

    //获取数据

    image_generator_.GetMetaData(image_metadata_);

    depth_generator_.GetMetaData(depth_metadata_);

 

    return true;

}

 

ImageGenerator &COpenniHand::getImageGenerator()

{

    return image_generator_;

}

 

DepthGenerator &COpenniHand::getDepthGenerator()

{

    return depth_generator_;

}

 

GestureGenerator &COpenniHand::getGestureGenerator()

{

    return gesture_generator_;

}

 

HandsGenerator &COpenniHand::getHandGenerator()

{

    return hand_generator_;

}

 

bool COpenniHand::CheckError(const char *error)

{

    if(status_ != XN_STATUS_OK) {

        cerr << error << ": " << xnGetStatusString( status_ ) << endl;

        return true;

    }

    return false;

}

 

void COpenniHand::CBGestureRecognized(GestureGenerator &generator, const XnChar *strGesture, const XnPoint3D *pIDPosition, const XnPoint3D *pEndPosition, void *pCookie)

{

    COpenniHand *openni = (COpenniHand*)pCookie;

    openni->hand_generator_.StartTracking(*pEndPosition);

}

 

void COpenniHand::CBGestureProgress(GestureGenerator &generator, const XnChar *strGesture, const XnPoint3D *pPosition, XnFloat fProgress, void *pCookie)

{

}

 

void COpenniHand::HandCreate(HandsGenerator &rHands, XnUserID xUID, const XnPoint3D *pPosition, XnFloat fTime, void *pCookie)

{

    COpenniHand *openni = (COpenniHand*)pCookie;

    XnPoint3D project_pos;

    openni->depth_generator_.ConvertRealWorldToProjective(1, pPosition, &project_pos);

    pair<XnUserID, XnPoint3D> hand_point_pair(xUID, XnPoint3D());//在进行pair类型的定义时，可以将第2个设置为空

    hand_point_pair.second = project_pos;

    openni->hand_points_.insert(hand_point_pair);//将检测到的手部存入map类型的hand_points_中。

 

    pair<XnUserID, vector<XnPoint3D>> hand_track_point(xUID, vector<XnPoint3D>());

    hand_track_point.second.push_back(project_pos);

    openni->hands_track_points_.insert(hand_track_point);

}

 

void COpenniHand::HandUpdate(HandsGenerator &rHands, XnUserID xUID, const XnPoint3D *pPosition, XnFloat fTime, void *pCookie)

{

    COpenniHand *openni = (COpenniHand*)pCookie;

    XnPoint3D project_pos;

    openni->depth_generator_.ConvertRealWorldToProjective(1, pPosition, &project_pos);

    openni->hand_points_.find(xUID)->second = project_pos;

    openni->hands_track_points_.find(xUID)->second.push_back(project_pos);

}

 

void COpenniHand::HandDestroy(HandsGenerator &rHands, XnUserID xUID, XnFloat fTime, void *pCookie)

{

    COpenniHand *openni = (COpenniHand*)pCookie;

    openni->hand_points_.erase(openni->hand_points_.find(xUID));

    openni->hands_track_points_.erase(openni->hands_track_points_.find(xUID ));

}

 

 

　　main.cpp:

 

#include <iostream>

 

#include "opencv2/highgui/highgui.hpp"

#include "opencv2/imgproc/imgproc.hpp"

#include <opencv2/core/core.hpp>

#include "copennihand.h"

 

#include <iostream>

 

#define DEPTH_SCALE_FACTOR 255./4096.

#define ROI_HAND_WIDTH 140

#define ROI_HAND_HEIGHT 140

#define MEDIAN_BLUR_K 5

#define XRES  640

#define YRES  480

#define DEPTH_SEGMENT_THRESH 5

#define MAX_HANDS_COLOR 10

#define MAX_HANDS_NUMBER  10

 

using namespace cv;

using namespace xn;

using namespace std;

 

 

int main (int argc, char **argv)

{

    vector<Scalar> color_array;//采用默认的10种颜色

    {

        color_array.push_back(Scalar(255, 0, 0));

        color_array.push_back(Scalar(0, 255, 0));

        color_array.push_back(Scalar(0, 0, 255));

        color_array.push_back(Scalar(255, 0, 255));

        color_array.push_back(Scalar(255, 255, 0));

        color_array.push_back(Scalar(0, 255, 255));

        color_array.push_back(Scalar(128, 255, 0));

        color_array.push_back(Scalar(0, 128, 255));

        color_array.push_back(Scalar(255, 0, 128));

        color_array.push_back(Scalar(255, 128, 255));

    }

    vector<unsigned int> hand_depth(MAX_HANDS_NUMBER, 0);

    vector<Rect> hands_roi(MAX_HANDS_NUMBER, Rect(XRES/2, YRES/2, ROI_HAND_WIDTH, ROI_HAND_HEIGHT));

 

    namedWindow("color image", CV_WINDOW_AUTOSIZE);

    namedWindow("depth image", CV_WINDOW_AUTOSIZE);

    namedWindow("hand_segment", CV_WINDOW_AUTOSIZE);//显示分割出来的手的区域

 

    COpenniHand openni;

    if(!openni.Initial())

        return 1;

 

    if(!openni.Start())

        return 1;

    while(1) {

        if(!openni.UpdateData()) {

            return 1;

        }

        /*获取并显示色彩图像*/

        Mat color_image_src(openni.image_metadata_.YRes(), openni.image_metadata_.XRes(),

                            CV_8UC3, (char *)openni.image_metadata_.Data());

        Mat color_image;

        cvtColor(color_image_src, color_image, CV_RGB2BGR);

 

        for(auto itUser = openni.hand_points_.cbegin(); itUser != openni.hand_points_.cend(); ++itUser) {

 

            circle(color_image, Point(itUser->second.X, itUser->second.Y),

                   5, color_array.at(itUser->first % color_array.size()), 3, 8);

 

            /*设置不同手部的深度*/

            hand_depth.at(itUser->first % MAX_HANDS_COLOR) = (unsigned int)(itUser->second.Z* DEPTH_SCALE_FACTOR);//itUser->first会导致程序出现bug

 

            /*设置不同手部的不同感兴趣区域*/

            hands_roi.at(itUser->first % MAX_HANDS_NUMBER) = Rect(itUser->second.X - ROI_HAND_WIDTH/2, itUser->second.Y - ROI_HAND_HEIGHT/2,

                                               ROI_HAND_WIDTH, ROI_HAND_HEIGHT);

            hands_roi.at(itUser->first % MAX_HANDS_NUMBER).x =  itUser->second.X - ROI_HAND_WIDTH/2;

            hands_roi.at(itUser->first % MAX_HANDS_NUMBER).y =  itUser->second.Y - ROI_HAND_HEIGHT/2;

            hands_roi.at(itUser->first % MAX_HANDS_NUMBER).width = ROI_HAND_WIDTH;

            hands_roi.at(itUser->first % MAX_HANDS_NUMBER).height = ROI_HAND_HEIGHT;

            if(hands_roi.at(itUser->first % MAX_HANDS_NUMBER).x <= 0)

                hands_roi.at(itUser->first % MAX_HANDS_NUMBER).x  = 0;

            if(hands_roi.at(itUser->first % MAX_HANDS_NUMBER).x > XRES)

                hands_roi.at(itUser->first % MAX_HANDS_NUMBER).x =  XRES;

            if(hands_roi.at(itUser->first % MAX_HANDS_NUMBER).y <= 0)

                hands_roi.at(itUser->first % MAX_HANDS_NUMBER).y = 0;

            if(hands_roi.at(itUser->first % MAX_HANDS_NUMBER).y > YRES)

                hands_roi.at(itUser->first % MAX_HANDS_NUMBER).y =  YRES;

        }

        imshow("color image", color_image);

 

        /*获取并显示深度图像*/

        Mat depth_image_src(openni.depth_metadata_.YRes(), openni.depth_metadata_.XRes(),

                            CV_16UC1, (char *)openni.depth_metadata_.Data());//因为kinect获取到的深度图像实际上是无符号的16位数据

        Mat depth_image;

        depth_image_src.convertTo(depth_image, CV_8U, DEPTH_SCALE_FACTOR);

        imshow("depth image", depth_image);

 

        //取出手的mask部分

        //不管原图像时多少通道的，mask矩阵声明为单通道就ok

        Mat hand_segment_mask(depth_image.size(), CV_8UC1, Scalar::all(0));

        for(auto itUser = openni.hand_points_.cbegin(); itUser != openni.hand_points_.cend(); ++itUser)

            for(int i = hands_roi.at(itUser->first % MAX_HANDS_NUMBER).x; i < std::min(hands_roi.at(itUser->first % MAX_HANDS_NUMBER).x+hands_roi.at(itUser->first % MAX_HANDS_NUMBER).width, XRES); i++)

                for(int j = hands_roi.at(itUser->first % MAX_HANDS_NUMBER).y; j < std::min(hands_roi.at(itUser->first % MAX_HANDS_NUMBER).y+hands_roi.at(itUser->first % MAX_HANDS_NUMBER).height, YRES); j++) {

                    hand_segment_mask.at<unsigned char>(j, i) = ((hand_depth.at(itUser->first % MAX_HANDS_NUMBER)-DEPTH_SEGMENT_THRESH) < depth_image.at<unsigned char>(j, i))

                                                                & ((hand_depth.at(itUser->first % MAX_HANDS_NUMBER)+DEPTH_SEGMENT_THRESH) > depth_image.at<unsigned char>(j,i));

                }

        medianBlur(hand_segment_mask, hand_segment_mask, MEDIAN_BLUR_K);

        Mat hand_segment(color_image.size(), CV_8UC3);

        color_image.copyTo(hand_segment, hand_segment_mask);

 

        imshow("hand_segment", hand_segment);

        waitKey(30);

    }

 

}