kinect 学习笔记二（深度图像的利用--抠取用户躯体）

最新推荐文章于 2020-04-13 13:43:53 发布
最新推荐文章于 2020-04-13 13:43:53 发布
阅读量997 收藏 2
点赞数
分类专栏： Computer Vision 文章标签： image Image Kinect

             kinect 学习笔记二（深度图像的利用--抠取用户躯体）

今天主要把深度数据和骨骼还有视频数据同步起来。算是上一次的三个的组合吧。期间遇到点白痴的问题整治了一下午：带ID的数据的ID是否准确。而且差点把自己的质疑给发到博客上来，竟然是自己代码的错误。伤心伤心。。。
 
直接把代码贴出来吧，也许有人觉得贴代码没水平，嗨，给自己留个小版本说不定以后还用得着，而且自信自己代码写的还算是规范，方便后来人嘛。再有一点，那个getTheContour函数画蛇添足了，实际直接利用深度数据的ID就可以抠出任务的区域。
 
先上实验结果：这是实时图像

\

 
然后是深度图像、骨骼图像和抠出的人体区域

\

\

\
 
 
这是代码，希望可以帮助到大家，当然，如果有错误欢迎指正：
 

#include <iostream> 
#include <fstream> 
#include  "math.h" 
#include "Windows.h"     
#include "MSR_NuiApi.h"     
#include "cv.h"     
#include "highgui.h"  
 
using namespace std; 
 
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, IplImage *colorImage); 
void getDepthImage(HANDLE &depthEvent, HANDLE &depthStreamHandle, IplImage *depthImage); 
void getSkeletonImage(HANDLE &skeletonEvent, IplImage *skeletonImage, IplImage *colorImage, IplImage *depthImage); 
void drawSkeleton(IplImage *image, CvPoint pointSet[], int witchone); 
void getTheContour(IplImage *image, int whichone, IplImage *mask);//得到各个人物的轮廓 
 
int main() 
{ 
    IplImage *colorImage = cvCreateImage(cvSize(640, 480), 8, 3); 
    IplImage *depthImage = cvCreateImage(cvSize(320, 240), 8, 3); 
    IplImage *skeletonImage = cvCreateImage(cvSize(320, 240), 8, 3); 
    IplImage *mask = cvCreateImage(cvSize(320, 240), 8, 3); 
 
    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;   
    } 
  
    //HANDLE hEvents[3]; 
    //int nEventIdx; 
    //hEvents[0] = colorEvent; 
    //hEvents[1] = depthEvent; 
    //hEvents[2] = skeletonEvent; 
    int a=0; 
    while (1) 
    { 
        //刚开始想用WaitForMultipleObjects，但是怎么调都是值显示视频，深度很少显示，骨骼直接不显示。 
        //自己理解不深入，只能临时用WaitForSingleObject这样了。 
        //nEventIdx = WaitForMultipleObjects(sizeof(hEvents)/sizeof(hEvents[0]), hEvents, FALSE, 10); 
        cout << nEventIdx << endl; 
 
        //switch(nEventIdx) 
        //{ 
        //case 0: 
        //  //if(WaitForSingleObject(colorEvent, 0)==0) 
        //  getColorImage(colorEvent, colorStreamHandle, colorImage); 
        //  break; 
        //case 1: 
        //  //if(WaitForSingleObject(depthEvent, 0)==0) 
        //  getDepthImage(depthEvent, depthStreamHandle, depthImage); 
        //  break; 
        //case 2: 
        //  //if(WaitForSingleObject(skeletonEvent, 0)==0) 
        //  getSkeletonImage(skeletonEvent, skeletonImage); 
        //  break; 
        //} 
 
        if(WaitForSingleObject(colorEvent, 0)==0) 
            getColorImage(colorEvent, colorStreamHandle, colorImage); 
        if(WaitForSingleObject(depthEvent, 0)==0) 
            getDepthImage(depthEvent, depthStreamHandle, depthImage); 
        if(WaitForSingleObject(skeletonEvent, INFINITE)==0)//这里使用INFINITE是为了避免没有激活skeletonEvent而跳过此代码出现colorimage频闪的现象 
            getSkeletonImage(skeletonEvent, skeletonImage, colorImage, depthImage); 
 
         
        for (int i=0; i<6; i++)  
        { 
            if(tracked[i] == TRUE) 
            { 
                cvZero(mask); 
                getTheContour(depthImage, i, mask); 
                tracked[i] = FALSE; 
                break; 
            } 
        } 
 
        cvShowImage("mask", mask); 
        cvShowImage("colorImage", colorImage); 
        cvShowImage("depthImage", depthImage); 
        cvShowImage("skeletonImage", skeletonImage); 
 
        if(cvWaitKey(20)==27) 
        { 
            cvReleaseImage(&colorImage); 
            cvReleaseImage(&depthImage); 
            cvReleaseImage(&skeletonImage); 
            break; 
        } 
    } 
 
    NuiShutdown(); 
    return 0; 
} 
 
void getColorImage(HANDLE &colorEvent, HANDLE &colorStreamHandle, IplImage *colorImage) 
{ 
    const NUI_IMAGE_FRAME *colorFrame = NULL; 
 
    NuiImageStreamGetNextFrame(colorStreamHandle, 0, &colorFrame); 
    NuiImageBuffer *pTexture = colorFrame->pFrameTexture;   
 
    KINECT_LOCKED_RECT LockedRect; 
    pTexture->LockRect(0, &LockedRect, NULL, 0);   
 
    if( LockedRect.Pitch != 0 )   
    {   
        //cvZero(colorImage); 
        for (int i=0; i<480; i++)   
        {   
            uchar* ptr = (uchar*)(colorImage->imageData+i*colorImage->widthStep);   
            BYTE * pBuffer = (BYTE*)(LockedRect.pBits)+i*LockedRect.Pitch;//每个字节代表一个颜色信息，直接使用BYTE   
            for (int j=0; j<640; 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];   
            }   
        }   
 
        //cvShowImage("colorImage", colorImage);//显示图像 
        //cvWaitKey(1); 
 
    }   
    else   
    {   
        cout<<"捕捉视频帧时发生错误"<<endl;   
    }   
     
    NuiImageStreamReleaseFrame( colorStreamHandle, colorFrame );   
} 
 
void getDepthImage(HANDLE &depthEvent, HANDLE &depthStreamHandle, IplImage *depthImage) 
{ 
    const NUI_IMAGE_FRAME *depthFrame = NULL; 
 
    NuiImageStreamGetNextFrame(depthStreamHandle, 0, &depthFrame); 
    NuiImageBuffer *pTexture = depthFrame->pFrameTexture;   
 
    KINECT_LOCKED_RECT LockedRect; 
    pTexture->LockRect(0, &LockedRect, NULL, 0);   
 
    RGBQUAD q; 
    //q.rgbBlue = q.rgbGreen = q.rgbRed = 0; 
    //cvZero(depthImage); 
    if( LockedRect.Pitch != 0 ) 
    { 
        for (int i=0; i<240; i++) 
        { 
            uchar *ptr = (uchar*)(depthImage->imageData+i*depthImage->widthStep); 
            BYTE *buffer = (BYTE*)(LockedRect.pBits)+i*LockedRect.Pitch; 
            USHORT *bufferRun = (USHORT*)buffer; 
            for (int j=0; j<320; j++) 
            { 
                int player = bufferRun[j]&7; 
                int data = (bufferRun[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; 
            } 
        } 
 
        //cvShowImage("depthImage", depthImage); 
        //cvWaitKey(1); 
    } 
    else 
    { 
        cout << "捕捉深度图像出现错误" << endl; 
    } 
 
    NuiImageStreamReleaseFrame(depthStreamHandle, depthFrame); 
 
} 
 
void getSkeletonImage(HANDLE &skeletonEvent, IplImage *skeletonImage, IplImage *colorImage, IplImage *depthImage) 
{ 
    /*两者效果竟然不一样。奇怪
    NUI_SKELETON_FRAME *skeletonFrame = NULL;
    NUI_SKELETON_FRAME skeletonFrame;*/ 
 
    NUI_SKELETON_FRAME skeletonFrame; 
    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;   
                //cout << "ok" << endl; 
                break; 
            }   
        }   
    } 
    else 
    { 
        cout << "没有找到合适的骨骼帧" << endl; 
        return;  
    } 
 
    if( !bFoundSkeleton )   
    {   
        return;  
    }   
 
    NuiTransformSmooth(&skeletonFrame,NULL);//平滑骨骼帧,消除抖动   
 
    cvZero(skeletonImage);   
    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++)//所有的坐标转化为深度图的坐标   
            {   
                NuiTransformSkeletonToDepthImageF(skeletonFrame.SkeletonData[i].SkeletonPositions[j], &fx, &fy );   
                skeletonPoint[i][j].x = (int)(fx*320+0.5f);   
                skeletonPoint[i][j].y = (int)(fy*240+0.5f);   
            }   
 
            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);//存储坐标点 
                    cvCircle(colorImage, colorPoint[i][j], 4, cvScalar(0, 255, 255), -1, 8, 0); 
                    //cvCircle(depthImage, skeletonPoint[i][j], 3, cvScalar(0, 255, 255), -1, 8, 0); 
                    cvCircle(skeletonImage, skeletonPoint[i][j], 3, cvScalar(0, 255, 255), -1, 8, 0); 
 
                    tracked[i] = TRUE; 
                } 
            } 
 
            drawSkeleton(colorImage, colorPoint[i], i); 
            //drawSkeleton(depthImage, skeletonPoint[i], i); 
            drawSkeleton(skeletonImage, skeletonPoint[i], i); 
        } 
    }   
 
    //cvShowImage("skeletonImage", skeletonImage);   
    //cvShowImage("skeletsdfonImage", colorImage);   
    //cvWaitKey(1);   
} 
 
void drawSkeleton(IplImage *image, CvPoint pointSet[], int witchone) 
{ 
    CvScalar color; 
    switch(witchone)//跟踪不同的人显示不同的颜色 
    { 
    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)) 
        cvLine(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)) 
        cvLine(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)) 
        cvLine(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)) 
        cvLine(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)) 
        cvLine(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)) 
        cvLine(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)) 
        cvLine(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)) 
        cvLine(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)) 
        cvLine(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)) 
        cvLine(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)) 
        cvLine(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)) 
        cvLine(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)) 
        cvLine(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)) 
        cvLine(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)) 
        cvLine(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)) 
        cvLine(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)) 
        cvLine(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)) 
        cvLine(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)) 
        cvLine(image, pointSet[NUI_SKELETON_POSITION_ANKLE_RIGHT], pointSet[NUI_SKELETON_POSITION_FOOT_RIGHT], color, 2); 
} 
 
 
void getTheContour(IplImage *image, int whichone, IplImage *mask)//根据给定的深度数据的关系（在getDepthImage()中的）确定不同的跟踪目标 
{ 
    for (int i=0; i<240; i++) 
    { 
        uchar *ptr = (uchar*)(image->imageData+i*image->widthStep); 
        uchar *ptrmask = (uchar*)(mask->imageData+i*mask->widthStep); 
        for (int j=0; j<320; 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; 
            } 
        } 
    } 
}


摘自 timebomb的专栏

BestChenqi
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
KINECT人物抠取 图像对齐（KINECTSDK + OPENCV）
在天一方，在水一角
11-26 5925
#include #include //windows的头文件，必须要，不然NuiApi.h用不了 #include //Kinect for windows 的头文件 #include "NuiApi.h" using namespace std; using namespace cv; #include //最远距离(mm) const int MAX_DISTANCE =
Kinect抠出人像并使用视频作为背景
void1001xn的博客
10-21 3397
void Reader_MultiSourceFrameArrived(object sender, MultiSourceFrameArrivedEventArgs e) { var reference = e.FrameReference.AcquireFrame(); using (var colorFrame...
Kinect开发学习笔记之（八）彩色、深度、骨骼和用户抠图结合
zouxy09的专栏
11-08 2万+
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/zou
用Kinect2将人物画面抠图显示在UE4中
qq_40544338的博客
04-13 1732
一、目的 1、将Kinect2人物画面抠图显示在UE4中 一、参考： 1、 一、过程 1、
kinect-v2彩色深度配准并修复深度图像并获取三维坐标
06-08
Kinect V2是一款先进的传感器设备，它能够捕获高质量的彩色图像、深度图像以及红外图像。在处理这些数据时，一个常见的任务是进行彩色深度配准，即将深度图像与彩色图像对应起来，以便更好地理解场景的三维结构。在...
基于Kinect的红外单目图像测距-matlab仿真
最新发布
11-15
基于Kinect 深度相机工作原理，研究Kinect 获取深度距离算法，开发深度测距程序，在不同光照条件下对检测到的人体中心位置进行测距实验，结果表明Kinect 测距具有抗光照不足的优势。为解决测量误差随物体到传感器的...
Kinect采集深度和彩色图像并同时保存
02-20
标题中的“Kinect采集深度和彩色图像并同时保存”指的是使用微软的Kinect设备来捕捉和存储深度图像和彩色图像。Kinect是一款先进的传感器设备，它不仅能够捕捉视频流（即彩色图像），还能够捕获空间深度信息，这对于...
Azure-Kinect-Unity-Body-Tracker-master.zip
05-08
标题中的"**Azure-Kinect-Unity-Body-Tracker-master.zip**"指示了这是一个与Azure Kinect在Unity中实现身体追踪相关的项目源代码压缩包。这个项目可能包含了一系列用于在Unity环境中利用Azure Kinect SDK进行人体...
kinect彩色图像对齐到深度并显示结果
06-08
在本文中，我们将深入探讨如何将Kinect v1.8传感器获取的彩色图像与深度图像进行对齐，并在OpenCV库的帮助下显示它们的结果。这个过程称为彩色-深度配准，对于理解和处理来自Kinect的数据至关重要。 首先，让我们...
kinectV2 抠图 自动拍照
05-10
利用Kinect抠图和识别简单动作自动拍照程序。 kinectV2 抠图 自动拍照。相关博客https://blog.csdn.net/baolinq/article/details/52388095
论文研究-结合彩色图像局部分割的Kinect深度图修复算法.pdf
07-22
针对Kinect深度图空洞和噪声存在降低三维目标检测和识别精度的问题，提出一种结合彩色图像局部分割的深度图修复算法。首先，利用区域连通性对空洞区域进行分析和标记；其次，根据空洞区域领域的深度直方图峰值数目判断空洞区域类型；再次，分割膨胀区域对应的彩色区域，获取空洞像素所在分割区域与其领域的交域（有效支撑区域），利用交域内的有效深度信息计算空洞像素；最后，利用引导滤波对深度图进行平滑、去噪。实验结果表明，经该算法处理后的深度图边缘细节更加清晰，具备微小梯度不变性，且测量精确度更高。
Kinect v2抠图程序
04-24
采用Kinect v2进行实时抠图，把目标人体完美融入背景图，完全实时，非常流畅。 C++写的
关于Kinect根据深度图对齐彩色图抠人比彩色图像人大的问题
清风似水流的专栏
08-08 5053
我根据Kinect自带的那个绿色抠人Demo，大家有没有发现抠出来的人比彩色图像中人变大了，该Demo是根据一个函数NuiImageGetColorPixelCoordinateFrameFromDepthPixelFrameAtResolution来对齐，导致我根据帧差法得到的前景图无法与抠出人的大小对齐，因此无法修复抠出来人边缘的抖动。下面，我介绍一个函数MapColorFrameToDept
简单的Kinect前景抠图
Lixam的专栏
11-07 6155
这个是用Kinect做三维扫描时的第一步，就是将感兴趣的前景部分取下来。大家都知道，Kinect的最大特点就是可以采集到深度数据，利用深度数据就可以将前景和背景区分开来。     长话短说，先上效果图吧。   再上源代码：   /*************************************** * Description:This program can rebuil
EmguCV获取kinect的彩色帧和红外图
k
08-06 3053
如不能正确配置EmguCV  看这里http://blog.csdn.net/qq_22033759/article/details/47299269 我使用的配置是Emgucv3+kinect2.0sdk+vs2015 用的是WinFrom，不是WPF，虽然WPF可以添加WinFrom控件 ，但还是原生的用着方便。 把Emgncv配好后添加kinect的引用 还是要在from中放
Kinect 应用开发实践之笔记（一）
飞天狐的专栏
08-15 2194
SDK 1.5 版本 提供的功能： 1、彩色图像获取 2、深度图像获取 3、骨骼跟踪数据获取 4、音频流获取 没有提供的功能： 1、姿势识别 2、动作识别 3、手势识别 。。。。。。 针对没有提供的高级功能，很多都可以根据深度数据进行相应的处理而获得。 最多支持 4 个设备同时连接在一台计算机上，但应用程序只能指定一个设备进行骨骼追踪。可以通过多进程实现多设备同时进行骨骼追
提取图像的骨架(Skeleton)算法
热门推荐
第二不及的专栏
06-15 3万+
图像的骨架似乎没有严格的数学定义，可认为是图像细化（Thinning）的产物（中轴可以看作一种骨架，其有严格的数学定义）。目前已经有许多细化算法，这些算法得到的骨架可能略有差异。本文实现了Khalid Sheed 的 K3M算法。该算法属于迭代腐蚀边界的一类算法，该类算法的思想是，假定从二值图像中物体的边界处同时开始燃烧，物体就会被逐步细化，但在燃烧过程中要保证满足一定条件的点被保留或者被“烧掉”
Kinect深度图像滤波
angshan19920512的博客
06-19 758
最近在做机器视觉方面的一点工作，用Kinect作sensor获取深度数据、颜色、手势识别等。非常感激CNBlog上的两篇博文：（1）独钓寒江的http://www.cnblogs.com/yangecnu/archive/2012/03/30/KinectSDK_Geting_Started.html 从中学到了不少关于在WPF平台上使用C#，利用微软Kinect SDK开发自己的应用程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值