Kinect開發學習筆記之（八）彩色、深度、骨骼和使用者摳圖結合

查志強發表於2016-08-02

筆記

【原文：http://blog.csdn.net/zouxy09/article/details/8163265】

Kinect開發學習筆記之（八）彩色、深度、骨骼和使用者摳圖結合

zouxy09@qq.com

http://blog.csdn.net/zouxy09

我的Kinect開發平臺是：

Win7 x86 + VS2010 + Kinect for Windows SDK v1.6 + OpenCV2.3.0

開發環境的搭建見上一文：

http://blog.csdn.net/zouxy09/article/details/8146055

本學習筆記以下面的方式組織：程式設計前期分析、程式碼與註釋和重要程式碼解析三部分。

要實現目標：整合前面所說的彩色影象、深度影象和骨骼影象，就是實現和SDK自帶的那個SkeletonView例程差不多的功能。另外，再增加使用者摳圖功能，這個功能和SDK自帶的那個Green Screen功能差不多。我們通過OpenCV來顯示。

一、程式設計前期分析

這裡因為是整合前面幾個學習筆記提到的功能，所以要了解的東西前面都已經瞭解了，這裡就不贅述了。這裡唯一有一個新的點就是使用者摳圖，我們再學習學習。

那麼叫摳圖啊？用過Photoshop或者AE等一般的影象或者視訊處理軟體的人應該不會陌生。所謂摳圖，就是把圖片或影像的某一部分從原始圖片或影像中分離出來成為單獨的圖層。主要功能是為了後期的合成做準備。如果還不瞭解的話，我們看過科幻電影或者一個特效視訊吧？某個人在恐龍旁邊、某個人在懸崖邊打架、某個人在天上飛等等，這些場景大家有沒有想過它是怎樣實現的啊？難道真的是實景拍的？你都會說了“怎麼可能！”。實際上很大一部分就是採用摳圖這個技術的，如果搞視訊特效處理的話，這個技術行業內好像叫“鍵控”。它在電視製作和電影製作中很常見，這種技術叫做綠屏摳像，就是演員或者播音員站在綠色底板前，然後錄完節目後，綠色背景摳出，換成其他場景，在一些科幻電影中演員不可能在實景中表演時常採用的造景手法。

在Kinect中我們也可以達到類似的效果。Kinect SDK使得這個很容易實現。這實際上就是現實增強的一個基本例子，現實增強應用非常有趣而且能夠獲得非常好的使用者體驗。許多藝術家使用Kinect來進行現實增強互動展覽。另外，這種技術也通常作為廣告和營銷的工具。

二、程式碼與註釋

[cpp]view
plain copy

#include <windows.h>  

#include <iostream>   

#include <NuiApi.h>  

#include <opencv2/opencv.hpp>  

using namespace std;  

using namespace cv;  

bool tracked[NUI_SKELETON_COUNT]={FALSE};   

CvPoint skeletonPoint[NUI_SKELETON_COUNT][NUI_SKELETON_POSITION_COUNT]={cvPoint(0,0)};   

CvPoint colorPoint[NUI_SKELETON_COUNT][NUI_SKELETON_POSITION_COUNT]={cvPoint(0,0)};   

void getColorImage(HANDLE &colorEvent, HANDLE &colorStreamHandle, Mat &colorImage);   

void getDepthImage(HANDLE &depthEvent, HANDLE &depthStreamHandle, Mat &depthImage);   

void getSkeletonImage(HANDLE &skeletonEvent, Mat &skeletonImage, Mat &colorImage, Mat &depthImage);   

void drawSkeleton(Mat &image, CvPoint pointSet[], int witchone);   

void getTheContour(Mat &image, int whichone, Mat &mask);  

int main(int argc, char *argv[])  

{  

    Mat colorImage;  

    colorImage.create(480, 640, CV_8UC3);   

    Mat depthImage;  

    depthImage.create(240, 320, CV_8UC3);   

    Mat skeletonImage;  

    skeletonImage.create(240, 320, CV_8UC3);   

    Mat mask;  

    mask.create(240, 320, CV_8UC3);   

    HANDLE colorEvent = CreateEvent( NULL, TRUE, FALSE, NULL );   

    HANDLE depthEvent = CreateEvent( NULL, TRUE, FALSE, NULL );   

    HANDLE skeletonEvent = CreateEvent( NULL, TRUE, FALSE, NULL );   

    HANDLE colorStreamHandle = NULL;   

    HANDLE depthStreamHandle = NULL;   

    HRESULT hr = NuiInitialize(NUI_INITIALIZE_FLAG_USES_COLOR | NUI_INITIALIZE_FLAG_USES_DEPTH_AND_PLAYER_INDEX | NUI_INITIALIZE_FLAG_USES_SKELETON);     

    if( hr != S_OK )     

    {     

        cout<<"NuiInitialize failed"<<endl;     

        return hr;     

    }   

    hr = NuiImageStreamOpen(NUI_IMAGE_TYPE_COLOR, NUI_IMAGE_RESOLUTION_640x480, NULL, 4, colorEvent, &colorStreamHandle);   

    if( hr != S_OK )     

    {     

        cout<<"Open the color Stream failed"<<endl;   

        NuiShutdown();   

        return hr;     

    }   

    hr = NuiImageStreamOpen(NUI_IMAGE_TYPE_DEPTH_AND_PLAYER_INDEX, NUI_IMAGE_RESOLUTION_320x240, NULL, 2, depthEvent, &depthStreamHandle);   

    if( hr != S_OK )     

    {     

        cout<<"Open the depth Stream failed"<<endl;   

        NuiShutdown();   

        return hr;     

    }   

    hr = NuiSkeletonTrackingEnable( skeletonEvent, 0 );//開啟骨骼跟蹤事件     

    if( hr != S_OK )     

    {     

        cout << "NuiSkeletonTrackingEnable failed" << endl;     

        NuiShutdown();   

        return hr;     

    }   

    namedWindow("mask", CV_WINDOW_AUTOSIZE);  

    namedWindow("colorImage", CV_WINDOW_AUTOSIZE);  

    namedWindow("depthImage", CV_WINDOW_AUTOSIZE);  

    namedWindow("skeletonImage", CV_WINDOW_AUTOSIZE);  

    while (1)   

    {   

        if(WaitForSingleObject(colorEvent, 0)==0)   

            getColorImage(colorEvent, colorStreamHandle, colorImage);   

        if(WaitForSingleObject(depthEvent, 0)==0)   

            getDepthImage(depthEvent, depthStreamHandle, depthImage);   

        //這裡使用INFINITE是為了避免沒有啟用skeletonEvent而跳過此程式碼出現colorimage頻閃的現象   

        if(WaitForSingleObject(skeletonEvent, INFINITE)==0)  

            getSkeletonImage(skeletonEvent, skeletonImage, colorImage, depthImage);   

        for (int i=0; i<6; i++)    

        {   

            if(tracked[i] == TRUE)   

            {   

                mask.setTo(0);  

                getTheContour(depthImage, i, mask);   

                tracked[i] = FALSE;   

                break;   

            }   

        }   

        imshow("mask", mask);   

        imshow("colorImage", colorImage);   

        imshow("depthImage", depthImage);   

        imshow("skeletonImage", skeletonImage);   

        if(cvWaitKey(1)==27)   

            break;   

    }   

    NuiShutdown();   

    return 0;   

}  

void getColorImage(HANDLE &colorEvent, HANDLE &colorStreamHandle, Mat &colorImage)   

{   

    const NUI_IMAGE_FRAME *colorFrame = NULL;   

    NuiImageStreamGetNextFrame(colorStreamHandle, 0, &colorFrame);   

    INuiFrameTexture *pTexture = colorFrame->pFrameTexture;     

    NUI_LOCKED_RECT LockedRect;   

    pTexture->LockRect(0, &LockedRect, NULL, 0);     

    if( LockedRect.Pitch != 0 )   

    {   

        for (int i=0; i<colorImage.rows; i++)   

        {  

            uchar *ptr = colorImage.ptr<uchar>(i);  //第i行的指標                    

            //每個位元組代表一個顏色資訊，直接使用uchar  

            uchar *pBuffer = (uchar*)(LockedRect.pBits) + i * LockedRect.Pitch;  

            for (int j=0; j<colorImage.cols; j++)   

            {   

                ptr[3*j] = pBuffer[4*j];  //內部資料是4個位元組，0-1-2是BGR，第4個現在未使用   

                ptr[3*j+1] = pBuffer[4*j+1];   

                ptr[3*j+2] = pBuffer[4*j+2];   

            }   

        }   

    }   

    else   

    {   

        cout<<"捕捉色彩影象出現錯誤"<<endl;   

    }  

    pTexture->UnlockRect(0);   

    NuiImageStreamReleaseFrame(colorStreamHandle, colorFrame );  

}   

void getDepthImage(HANDLE &depthEvent, HANDLE &depthStreamHandle, Mat &depthImage)   

{   

    const NUI_IMAGE_FRAME *depthFrame = NULL;   

    NuiImageStreamGetNextFrame(depthStreamHandle, 0, &depthFrame);   

    INuiFrameTexture *pTexture = depthFrame->pFrameTexture;     

    NUI_LOCKED_RECT LockedRect;   

    pTexture->LockRect(0, &LockedRect, NULL, 0);     

    RGBQUAD q;   

    if( LockedRect.Pitch != 0 )   

    {   

        for (int i=0; i<depthImage.rows; i++)   

        {   

            uchar *ptr = depthImage.ptr<uchar>(i);   

            uchar *pBuffer = (uchar*)(LockedRect.pBits) + i * LockedRect.Pitch;  

            USHORT *pBufferRun = (USHORT*) pBuffer;   

            for (int j=0; j<depthImage.cols; j++)   

            {   

                int player = pBufferRun[j]&7;   

                int data = (pBufferRun[j]&0xfff8) >> 3;   

                uchar imageData = 255-(uchar)(256*data/0x0fff);   

                q.rgbBlue = q.rgbGreen = q.rgbRed = 0;   

                switch(player)   

                {   

                    case 0:     

                        q.rgbRed = imageData / 2;     

                        q.rgbBlue = imageData / 2;     

                        q.rgbGreen = imageData / 2;     

                        break;     

                    case 1:      

                        q.rgbRed = imageData;     

                        break;     

                    case 2:     

                        q.rgbGreen = imageData;     

                        break;     

                    case 3:     

                        q.rgbRed = imageData / 4;     

                        q.rgbGreen = q.rgbRed*4;  //這裡利用乘的方法，而不用原來的方法可以避免不整除的情況   

                        q.rgbBlue = q.rgbRed*4;  //可以在後面的getTheContour()中配合使用，避免遺漏一些情況   

                        break;     

                    case 4:     

                        q.rgbBlue = imageData / 4;    

                        q.rgbRed = q.rgbBlue*4;     

                        q.rgbGreen = q.rgbBlue*4;     

                        break;     

                    case 5:     

                        q.rgbGreen = imageData / 4;    

                        q.rgbRed = q.rgbGreen*4;     

                        q.rgbBlue = q.rgbGreen*4;     

                        break;     

                    case 6:     

                        q.rgbRed = imageData / 2;     

                        q.rgbGreen = imageData / 2;      

                        q.rgbBlue = q.rgbGreen*2;     

                        break;     

                    case 7:     

                        q.rgbRed = 255 - ( imageData / 2 );     

                        q.rgbGreen = 255 - ( imageData / 2 );     

                        q.rgbBlue = 255 - ( imageData / 2 );   

                }      

                ptr[3*j] = q.rgbBlue;   

                ptr[3*j+1] = q.rgbGreen;   

                ptr[3*j+2] = q.rgbRed;   

            }   

        }   

    }   

    else   

    {   

        cout << "捕捉深度影象出現錯誤" << endl;   

    }   

    pTexture->UnlockRect(0);  

    NuiImageStreamReleaseFrame(depthStreamHandle, depthFrame);    

}   

void getSkeletonImage(HANDLE &skeletonEvent, Mat &skeletonImage, Mat &colorImage, Mat &depthImage)   

{   

    NUI_SKELETON_FRAME skeletonFrame = {0};  

    bool bFoundSkeleton = false;    

    if(NuiSkeletonGetNextFrame( 0, &skeletonFrame ) == S_OK )     

    {     

        for( int i = 0 ; i < NUI_SKELETON_COUNT ; i++ )     

        {     

            if( skeletonFrame.SkeletonData[i].eTrackingState == NUI_SKELETON_TRACKED )   

            {     

                bFoundSkeleton = true;     

                break;   

            }     

        }     

    }   

    else   

    {   

        cout << "沒有找到合適的骨骼幀" << endl;   

        return;    

    }   

    if( !bFoundSkeleton )     

    {     

        return;    

    }     

    NuiTransformSmooth(&skeletonFrame, NULL);//平滑骨骼幀,消除抖動     

    skeletonImage.setTo(0);     

    for( int i = 0 ; i < NUI_SKELETON_COUNT ; i++ )     

    {     

        if( skeletonFrame.SkeletonData[i].eTrackingState == NUI_SKELETON_TRACKED &&     

            skeletonFrame.SkeletonData[i].eSkeletonPositionTrackingState[NUI_SKELETON_POSITION_SHOULDER_CENTER] != NUI_SKELETON_POSITION_NOT_TRACKED)     

        {     

            float fx, fy;     

            for (int j = 0; j < NUI_SKELETON_POSITION_COUNT; j++)//所有的座標轉化為深度圖的座標     

            {     

                NuiTransformSkeletonToDepthImage(skeletonFrame.SkeletonData[i].SkeletonPositions[j], &fx, &fy );     

                skeletonPoint[i][j].x = (int)fx;     

                skeletonPoint[i][j].y = (int)fy;     

            }     

            for (int j=0; j<NUI_SKELETON_POSITION_COUNT ; j++)     

            {     

                if (skeletonFrame.SkeletonData[i].eSkeletonPositionTrackingState[j] != NUI_SKELETON_POSITION_NOT_TRACKED)//跟蹤點一用有三種狀態：1沒有被跟蹤到，2跟蹤到，3根據跟蹤到的估計到     

                {     

                    LONG colorx, colory;   

                    NuiImageGetColorPixelCoordinatesFromDepthPixel(NUI_IMAGE_RESOLUTION_640x480, 0,    

                        skeletonPoint[i][j].x, skeletonPoint[i][j].y, 0,&colorx, &colory);   

                    colorPoint[i][j].x = int(colorx);  

                    colorPoint[i][j].y = int(colory); //儲存座標點   

                    circle(colorImage, colorPoint[i][j], 4, cvScalar(0, 255, 255), 1, 8, 0);   

                    circle(skeletonImage, skeletonPoint[i][j], 3, cvScalar(0, 255, 255), 1, 8, 0);   

                    tracked[i] = TRUE;   

                }   

            }   

            drawSkeleton(colorImage, colorPoint[i], i);    

            drawSkeleton(skeletonImage, skeletonPoint[i], i);   

        }   

    }     

}   

void drawSkeleton(Mat &image, CvPoint pointSet[], int whichone)   

{   

    CvScalar color;   

    switch(whichone) //跟蹤不同的人顯示不同的顏色   

    {   

    case 0:   

        color = cvScalar(255);   

        break;   

    case 1:   

        color = cvScalar(0,255);   

        break;   

    case 2:   

        color = cvScalar(0, 0, 255);   

        break;   

    case 3:   

        color = cvScalar(255, 255, 0);   

        break;   

    case 4:   

        color = cvScalar(255, 0, 255);   

        break;   

    case 5:   

        color = cvScalar(0, 255, 255);   

        break;   

    }   

    if((pointSet[NUI_SKELETON_POSITION_HEAD].x!=0 || pointSet[NUI_SKELETON_POSITION_HEAD].y!=0) &&   

        (pointSet[NUI_SKELETON_POSITION_SHOULDER_CENTER].x!=0 || pointSet[NUI_SKELETON_POSITION_SHOULDER_CENTER].y!=0))   

        line(image, pointSet[NUI_SKELETON_POSITION_HEAD], pointSet[NUI_SKELETON_POSITION_SHOULDER_CENTER], color, 2);   

    if((pointSet[NUI_SKELETON_POSITION_SHOULDER_CENTER].x!=0 || pointSet[NUI_SKELETON_POSITION_SHOULDER_CENTER].y!=0) &&   

        (pointSet[NUI_SKELETON_POSITION_SPINE].x!=0 || pointSet[NUI_SKELETON_POSITION_SPINE].y!=0))   

        line(image, pointSet[NUI_SKELETON_POSITION_SHOULDER_CENTER], pointSet[NUI_SKELETON_POSITION_SPINE], color, 2);   

    if((pointSet[NUI_SKELETON_POSITION_SPINE].x!=0 || pointSet[NUI_SKELETON_POSITION_SPINE].y!=0) &&   

        (pointSet[NUI_SKELETON_POSITION_HIP_CENTER].x!=0 || pointSet[NUI_SKELETON_POSITION_HIP_CENTER].y!=0))   

        line(image, pointSet[NUI_SKELETON_POSITION_SPINE], pointSet[NUI_SKELETON_POSITION_HIP_CENTER], color, 2);   

    //左上肢   

    if((pointSet[NUI_SKELETON_POSITION_SHOULDER_CENTER].x!=0 || pointSet[NUI_SKELETON_POSITION_SHOULDER_CENTER].y!=0) &&   

        (pointSet[NUI_SKELETON_POSITION_SHOULDER_LEFT].x!=0 || pointSet[NUI_SKELETON_POSITION_SHOULDER_LEFT].y!=0))   

        line(image, pointSet[NUI_SKELETON_POSITION_SHOULDER_CENTER], pointSet[NUI_SKELETON_POSITION_SHOULDER_LEFT], color, 2);   

    if((pointSet[NUI_SKELETON_POSITION_SHOULDER_LEFT].x!=0 || pointSet[NUI_SKELETON_POSITION_SHOULDER_LEFT].y!=0) &&   

        (pointSet[NUI_SKELETON_POSITION_ELBOW_LEFT].x!=0 || pointSet[NUI_SKELETON_POSITION_ELBOW_LEFT].y!=0))   

        line(image, pointSet[NUI_SKELETON_POSITION_SHOULDER_LEFT], pointSet[NUI_SKELETON_POSITION_ELBOW_LEFT], color, 2);   

    if((pointSet[NUI_SKELETON_POSITION_ELBOW_LEFT].x!=0 || pointSet[NUI_SKELETON_POSITION_ELBOW_LEFT].y!=0) &&   

        (pointSet[NUI_SKELETON_POSITION_WRIST_LEFT].x!=0 || pointSet[NUI_SKELETON_POSITION_WRIST_LEFT].y!=0))   

        line(image, pointSet[NUI_SKELETON_POSITION_ELBOW_LEFT], pointSet[NUI_SKELETON_POSITION_WRIST_LEFT], color, 2);   

    if((pointSet[NUI_SKELETON_POSITION_WRIST_LEFT].x!=0 || pointSet[NUI_SKELETON_POSITION_WRIST_LEFT].y!=0) &&   

        (pointSet[NUI_SKELETON_POSITION_HAND_LEFT].x!=0 || pointSet[NUI_SKELETON_POSITION_HAND_LEFT].y!=0))   

        line(image, pointSet[NUI_SKELETON_POSITION_WRIST_LEFT], pointSet[NUI_SKELETON_POSITION_HAND_LEFT], color, 2);   

    //右上肢   

    if((pointSet[NUI_SKELETON_POSITION_SHOULDER_CENTER].x!=0 || pointSet[NUI_SKELETON_POSITION_SHOULDER_CENTER].y!=0) &&   

        (pointSet[NUI_SKELETON_POSITION_SHOULDER_RIGHT].x!=0 || pointSet[NUI_SKELETON_POSITION_SHOULDER_RIGHT].y!=0))   

        line(image, pointSet[NUI_SKELETON_POSITION_SHOULDER_CENTER], pointSet[NUI_SKELETON_POSITION_SHOULDER_RIGHT], color, 2);   

    if((pointSet[NUI_SKELETON_POSITION_SHOULDER_RIGHT].x!=0 || pointSet[NUI_SKELETON_POSITION_SHOULDER_RIGHT].y!=0) &&   

        (pointSet[NUI_SKELETON_POSITION_ELBOW_RIGHT].x!=0 || pointSet[NUI_SKELETON_POSITION_ELBOW_RIGHT].y!=0))   

        line(image, pointSet[NUI_SKELETON_POSITION_SHOULDER_RIGHT], pointSet[NUI_SKELETON_POSITION_ELBOW_RIGHT], color, 2);   

    if((pointSet[NUI_SKELETON_POSITION_ELBOW_RIGHT].x!=0 || pointSet[NUI_SKELETON_POSITION_ELBOW_RIGHT].y!=0) &&   

        (pointSet[NUI_SKELETON_POSITION_WRIST_RIGHT].x!=0 || pointSet[NUI_SKELETON_POSITION_WRIST_RIGHT].y!=0))   

        line(image, pointSet[NUI_SKELETON_POSITION_ELBOW_RIGHT], pointSet[NUI_SKELETON_POSITION_WRIST_RIGHT], color, 2);   

    if((pointSet[NUI_SKELETON_POSITION_WRIST_RIGHT].x!=0 || pointSet[NUI_SKELETON_POSITION_WRIST_RIGHT].y!=0) &&   

        (pointSet[NUI_SKELETON_POSITION_HAND_RIGHT].x!=0 || pointSet[NUI_SKELETON_POSITION_HAND_RIGHT].y!=0))   

        line(image, pointSet[NUI_SKELETON_POSITION_WRIST_RIGHT], pointSet[NUI_SKELETON_POSITION_HAND_RIGHT], color, 2);   

    //左下肢   

    if((pointSet[NUI_SKELETON_POSITION_HIP_CENTER].x!=0 || pointSet[NUI_SKELETON_POSITION_HIP_CENTER].y!=0) &&   

        (pointSet[NUI_SKELETON_POSITION_HIP_LEFT].x!=0 || pointSet[NUI_SKELETON_POSITION_HIP_LEFT].y!=0))   

        line(image, pointSet[NUI_SKELETON_POSITION_HIP_CENTER], pointSet[NUI_SKELETON_POSITION_HIP_LEFT], color, 2);   

    if((pointSet[NUI_SKELETON_POSITION_HIP_LEFT].x!=0 || pointSet[NUI_SKELETON_POSITION_HIP_LEFT].y!=0) &&   

        (pointSet[NUI_SKELETON_POSITION_KNEE_LEFT].x!=0 || pointSet[NUI_SKELETON_POSITION_KNEE_LEFT].y!=0))   

        line(image, pointSet[NUI_SKELETON_POSITION_HIP_LEFT], pointSet[NUI_SKELETON_POSITION_KNEE_LEFT], color, 2);   

    if((pointSet[NUI_SKELETON_POSITION_KNEE_LEFT].x!=0 || pointSet[NUI_SKELETON_POSITION_KNEE_LEFT].y!=0) &&   

        (pointSet[NUI_SKELETON_POSITION_ANKLE_LEFT].x!=0 || pointSet[NUI_SKELETON_POSITION_ANKLE_LEFT].y!=0))   

        line(image, pointSet[NUI_SKELETON_POSITION_KNEE_LEFT], pointSet[NUI_SKELETON_POSITION_ANKLE_LEFT], color, 2);   

    if((pointSet[NUI_SKELETON_POSITION_ANKLE_LEFT].x!=0 || pointSet[NUI_SKELETON_POSITION_ANKLE_LEFT].y!=0) &&    

        (pointSet[NUI_SKELETON_POSITION_FOOT_LEFT].x!=0 || pointSet[NUI_SKELETON_POSITION_FOOT_LEFT].y!=0))   

        line(image, pointSet[NUI_SKELETON_POSITION_ANKLE_LEFT], pointSet[NUI_SKELETON_POSITION_FOOT_LEFT], color, 2);   

    //右下肢   

    if((pointSet[NUI_SKELETON_POSITION_HIP_CENTER].x!=0 || pointSet[NUI_SKELETON_POSITION_HIP_CENTER].y!=0) &&   

        (pointSet[NUI_SKELETON_POSITION_HIP_RIGHT].x!=0 || pointSet[NUI_SKELETON_POSITION_HIP_RIGHT].y!=0))   

        line(image, pointSet[NUI_SKELETON_POSITION_HIP_CENTER], pointSet[NUI_SKELETON_POSITION_HIP_RIGHT], color, 2);   

    if((pointSet[NUI_SKELETON_POSITION_HIP_RIGHT].x!=0 || pointSet[NUI_SKELETON_POSITION_HIP_RIGHT].y!=0) &&   

        (pointSet[NUI_SKELETON_POSITION_KNEE_RIGHT].x!=0 || pointSet[NUI_SKELETON_POSITION_KNEE_RIGHT].y!=0))   

        line(image, pointSet[NUI_SKELETON_POSITION_HIP_RIGHT], pointSet[NUI_SKELETON_POSITION_KNEE_RIGHT],color, 2);   

    if((pointSet[NUI_SKELETON_POSITION_KNEE_RIGHT].x!=0 || pointSet[NUI_SKELETON_POSITION_KNEE_RIGHT].y!=0) &&   

        (pointSet[NUI_SKELETON_POSITION_ANKLE_RIGHT].x!=0 || pointSet[NUI_SKELETON_POSITION_ANKLE_RIGHT].y!=0))   

        line(image, pointSet[NUI_SKELETON_POSITION_KNEE_RIGHT], pointSet[NUI_SKELETON_POSITION_ANKLE_RIGHT], color, 2);   

    if((pointSet[NUI_SKELETON_POSITION_ANKLE_RIGHT].x!=0 || pointSet[NUI_SKELETON_POSITION_ANKLE_RIGHT].y!=0) &&   

        (pointSet[NUI_SKELETON_POSITION_FOOT_RIGHT].x!=0 || pointSet[NUI_SKELETON_POSITION_FOOT_RIGHT].y!=0))   

        line(image, pointSet[NUI_SKELETON_POSITION_ANKLE_RIGHT], pointSet[NUI_SKELETON_POSITION_FOOT_RIGHT], color, 2);   

}   

 //根據給定的深度資料的關係（在getDepthImage()中的）確定不同的跟蹤目標   

void getTheContour(Mat &image, int whichone, Mat &mask)  

{   

    for (int i=0; i<image.rows; i++)   

    {   

        uchar *ptr = image.ptr<uchar>(i);   

        uchar *ptrmask = mask.ptr<uchar>(i);    

        for (int j=0; j<image.cols; j++)   

        {   

            if (ptr[3*j]==0 && ptr[3*j+1]==0 && ptr[3*j+2]==0) //都為0的時候予以忽略   

            {   

                ptrmask[3*j]=ptrmask[3*j+1]=ptrmask[3*j+2]=0;   

            }else if(ptr[3*j]==0 && ptr[3*j+1]==0 && ptr[3*j+2]!=0)//ID為1的時候，顯示綠色   

            {   

                ptrmask[3*j] = 0;   

                ptrmask[3*j+1] = 255;   

                ptrmask[3*j+2] = 0;   

            }else if (ptr[3*j]==0 && ptr[3*j+1]!=0 && ptr[3*j+2]==0)//ID為2的時候，顯示紅色   

            {   

                ptrmask[3*j] = 0;   

                ptrmask[3*j+1] = 0;   

                ptrmask[3*j+2] = 255;   

            }else if (ptr[3*j]==ptr[3*j+1] && ptr[3*j]==4*ptr[3*j+2])//ID為3的時候   

            {   

                ptrmask[3*j] = 255;   

                ptrmask[3*j+1] = 255;   

                ptrmask[3*j+2] = 0;   

            }else if (4*ptr[3*j]==ptr[3*j+1] && ptr[3*j+1]==ptr[3*j+2])//ID為4的時候   

            {   

                ptrmask[3*j] = 255;   

                ptrmask[3*j+1] = 0;   

                ptrmask[3*j+2] = 255;   

            }else if (ptr[3*j]==4*ptr[3*j+1] && ptr[3*j]==ptr[3*j+2])//ID為5的時候   

            {   

                ptrmask[3*j] = 0;   

                ptrmask[3*j+1] = 255;   

                ptrmask[3*j+2] = 255;   

            }else if (ptr[3*j]==2*ptr[3*j+1] && ptr[3*j+1]==ptr[3*j+2])//ID為6的時候   

            {   

                ptrmask[3*j] = 255;   

                ptrmask[3*j+1] = 255;   

                ptrmask[3*j+2] = 255;   

            }else if (ptr[3*j]==ptr[3*j+1] && ptr[3*j]==ptr[3*j+2])//ID為7的時候或者ID為0的時候，顯示藍色   

            {   

                ptrmask[3*j] = 255;   

                ptrmask[3*j+1] = 0;   

                ptrmask[3*j+2] = 0;   

            }else   

            {   

                cout <<"如果輸出這段程式碼，說明有遺漏的情況，請查詢getTheContour函式" << endl;   

            }   

        }   

    }   

}

三、程式碼解析

這裡，在對前面所說的彩色影象、深度影象和骨骼影象的整合功能的實現上，就是通過整合前面工作的程式碼而已（請參考之前的博文）。然後唯一有一個新的東西就是摳圖，我們需要把使用者扣出來，顯示與背景不一樣的顏色，具體的函式就是：

void getTheContour(Mat &image, int whichone, Mat &mask)；

呼叫它的時候，傳入的是深度影象image，我們在深度影象處理的時候，也就是getDepthImage 函式裡面對深度資料已經做了處理，已經將玩家的ID資料轉換為RGBQUAD 格式的資料了，所以使用者的ID資料已經隱含的在深度影象的每個畫素中表示了，所以這裡我們只需要分析每個畫素的RGB值就可以對應的知道是哪個ID了，那麼屬於某個ID的畫素我們就用某種顏色來表示，其他背景畫素我們就用藍色來表示。這樣就完成了摳圖。

實際上，我們之前提到的getDepthImage 函式就是處理深度資料的每一個畫素，如果屬於同一個使用者的ID，那麼畫素就標為同種顏色，不同的使用者，其ID不一樣，顏色的標示也不一樣，如果不屬於某個使用者的畫素，那麼就採用原來的深度值，而getTheContour函式實際上就是這裡不一樣而已。“如果不屬於某個使用者的畫素，那麼就採用原來的深度值”，這裡改為“如果不屬於某個使用者的畫素，那麼就將畫素值賦值為藍色”。

既然你都把使用者扣出來了，那麼把他弄到你給定的一個圖片場景裡面應該不難了吧。呵呵，相信大家都有各種辦法的。

至此，本文的目標就達到了，下面是結果。其實右邊是彩色影象，在彩色影象裡面使用者的骨架也是被標註出來的，只是本人不宜拋頭露面，所以就拋棄這部分的截圖了。

另外，感覺到這裡，Kinect SDK能提供的基本資料我們會獲取了，也就是勉勉強強把地基打好了，那麼後面的工作就是在上面創造屬於你的世界了。我們後面會學習基於Kinect的姿態、手勢識別等等的內容，通過他們去構建良好的人機互動程式。當然，Kinect還包含有語音識別的功能，這裡暫時就不涉及了。

Kinect開發學習筆記之（七）骨骼資料的提取
2016-08-02
筆記
Kinect開發學習筆記之（二）Kinect開發學習資源整理
2016-08-02
筆記
Kinect開發學習筆記之（一）Kinect介紹和應用
2016-08-02
筆記
Kinect開發學習筆記之（三）Kinect開發環境配置
2016-08-02
筆記開發環境
Kinect開發學習筆記之（六）帶遊戲者ID的深度資料的提取
2016-08-02
筆記遊戲
Kinect開發學習筆記之（五）不帶遊戲者ID的深度資料的提取
2016-08-02
筆記遊戲
深度學習和圖形學渲染的結合和應用
2022-05-28
深度學習
Kinect開發學習筆記之（四）提取顏色資料並用OpenCV顯示
2016-08-02
筆記OpenCV
hive學習筆記之八：Sqoop
2021-07-07
Hive筆記OOP
substrate學習筆記9：開發智慧合約
2022-03-30
筆記
深度學習讀書筆記之RBM
2016-05-08
深度學習筆記
Vue & Bootstrap 結合學習筆記（一）
2018-06-20
Vueboot筆記
Vue & Bootstrap 結合學習筆記（二）
2018-06-21
Vueboot筆記
《Mastering Delphi 6》學習筆記之八 (轉)
2007-12-09
AST筆記
Webpack4 學習筆記八開發環境和生產環境配置
2019-01-25
Web筆記開發環境
深度學習keras筆記
2020-12-17
深度學習Keras筆記
深度學習筆記一
2018-03-09
深度學習筆記
JavaScript學習筆記（八）—— 補
2019-02-09
JavaScript筆記
Spss 學習筆記（八）
2004-12-13
SPSS筆記
laravel學習筆記之開發環境搭建
2021-11-21
Laravel筆記開發環境
Django之“學習筆記”網站開發1
2018-01-18
Django筆記網站
Open CV 學習開發筆記之概述（一）
2017-10-23
筆記
Deep Learning（深度學習）學習筆記整理系列之（一）
2013-04-08
深度學習筆記
substrate學習筆記10：開發erc20合約
2022-03-30
筆記
systemtap和火焰圖學習筆記
2018-03-22
筆記
【深度學習】深度學習md筆記總結第1篇：深度學習課程,要求【附程式碼文件】
2024-03-19
深度學習筆記
《筆記》之學習高併發
2019-03-25
筆記
以太坊開發實戰學習-合約安全(八)
2021-09-09
Kinect影象骨骼點夾角處理
2017-09-15
MySQL學習筆記之命令總結
2015-12-06
MySql筆記
CUDA 學習筆記之gpu結構
2010-04-30
筆記GPU
substrate學習筆記8：ink合約開發之初體驗
2022-03-30
筆記
深度學習框架Pytorch學習筆記
2023-02-27
深度學習框架PyTorch筆記
HexMap學習筆記(八)——水體
2019-05-20
筆記
OS學習筆記八：死鎖
2017-10-11
筆記
22張精煉圖筆記，深度學習專項學習必備
2019-12-30
筆記深度學習
學習筆記|AS入門（八）元件篇之ContentProvider
2017-12-21
筆記元件IDE
Rest API 開發學習筆記
2014-01-23
RESTAPI筆記

Kinect開發學習筆記之（八）彩色、深度、骨骼和使用者摳圖結合

相關文章