Kinect学习（七）：综合提取彩色、深度、人体骨骼点

最新推荐文章于 2021-06-03 10:27:02 发布
最新推荐文章于 2021-06-03 10:27:02 发布
阅读量4.8k 收藏 35
点赞数 5
分类专栏： Kinect 文章标签： Kinect
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hongbin_xu/article/details/80907403
版权

前言

前面的博客中介绍了如何通过Kinect获得彩色图像、深度图像以及人体骨骼点：

这次要将这几者综合起来，同时从Kinect那里拿来这些数据。

代码

这里的代码只是将前面几篇博客中的内容整合了一下，就不做过多说明了。

#include <Windows.h>
#include <iostream>
#include <NuiApi.h>
#include <opencv2/opencv.hpp>

using namespace std;
using namespace cv;

typedef struct structBGR {
    BYTE blue;
    BYTE green;
    BYTE red;
    BYTE player;
} BGR;

bool tracked[NUI_SKELETON_COUNT] = { FALSE };
cv::Point skeletonPoint[NUI_SKELETON_COUNT][NUI_SKELETON_POSITION_COUNT] = { cv::Point(0, 0) };
cv::Point colorPoint[NUI_SKELETON_COUNT][NUI_SKELETON_POSITION_COUNT] = { cv::Point(0, 0) };

void getColorImage(HANDLE & colorStreamHandle, cv::Mat & colorImg);
BGR Depth2RGB(USHORT depthID);
void getDepthImage(HANDLE & depthStreamHandle, cv::Mat & depthImg, cv::Mat & mask);
void drawSkeleton(cv::Mat &img, cv::Point pointSet[], int which_one);
void getSkeletonImage(cv::Mat & skeletonImg, cv::Mat & colorImg);

int main(int argc, char* argv[])
{
    cv::Mat colorImg;
    colorImg.create(480, 640, CV_8UC3);
    cv::Mat depthImg;
    depthImg.create(240, 320, CV_8UC3);
    cv::Mat skeletonImg;
    skeletonImg.create(240, 320, CV_8UC3);
    cv::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;

    hr = NuiInitialize(NUI_INITIALIZE_FLAG_USES_COLOR | NUI_INITIALIZE_FLAG_USES_DEPTH_AND_PLAYER_INDEX
        | NUI_INITIALIZE_FLAG_USES_SKELETON);
    if (FAILED(hr))
    {
        cout << "Nui initialize failed." << endl;
        return hr;
    }

    hr = NuiImageStreamOpen(NUI_IMAGE_TYPE_COLOR, NUI_IMAGE_RESOLUTION_640x480, 0, 2, colorEvent, &colorStreamHandle);
    if (FAILED(hr))
    {
        cout << "Can not open color stream." << endl;
        return hr;
    }

    hr = NuiImageStreamOpen(NUI_IMAGE_TYPE_DEPTH_AND_PLAYER_INDEX, NUI_IMAGE_RESOLUTION_320x240, 0, 2, depthEvent, &depthStreamHandle);
    if (FAILED(hr))
    {
        cout << "Can not open depth stream." << endl;
        return hr;
    }

    hr = NuiSkeletonTrackingEnable(skeletonEvent, 0);
    if (FAILED(hr))
    {
        cout << "Can not enable skeleton tracking." << endl;
        return hr;
    }

    cv::namedWindow("mask", CV_WINDOW_AUTOSIZE);
    cv::namedWindow("colorImg", CV_WINDOW_AUTOSIZE);
    cv::namedWindow("depthImg", CV_WINDOW_AUTOSIZE);
    cv::namedWindow("skeletonImg", CV_WINDOW_AUTOSIZE);

    while (1)
    {
        if (WaitForSingleObject(colorEvent, 0) == 0)
        {
            getColorImage(colorStreamHandle, colorImg);
        }

        if (WaitForSingleObject(depthEvent, 0) == 0)
        {
            getDepthImage(depthStreamHandle, depthImg, mask);
        }

        if (WaitForSingleObject(skeletonEvent, 0) == 0)
        {
            getSkeletonImage(skeletonImg, colorImg);
        }

        cv::imshow("mask", mask);
        cv::imshow("colorImg", colorImg);
        cv::imshow("depthImg", depthImg);
        cv::imshow("skeletonImg", skeletonImg);


        if (cv::waitKey(20) == 27)
            break;
    }

    NuiShutdown();
    cv::destroyAllWindows();


    return 0;
}

void getColorImage(HANDLE & colorStreamHandle, cv::Mat & colorImg)
{
    const NUI_IMAGE_FRAME * pImageFrame = NULL;

    HRESULT hr = NuiImageStreamGetNextFrame(colorStreamHandle, 0, &pImageFrame);
    if (FAILED(hr))
    {
        cout << "Could not get color image" << endl;
        NuiShutdown();
        return;
    }

    INuiFrameTexture * pTexture = pImageFrame->pFrameTexture;
    NUI_LOCKED_RECT LockedRect;

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

    if (LockedRect.Pitch != 0)
    {
        for (int i = 0; i < colorImg.rows; i++)
        {
            uchar *ptr = colorImg.ptr<uchar>(i);    //第i行的指针

                                            //每个字节代表一个颜色信息，直接使用uchar
            uchar *pBuffer = (uchar*)(LockedRect.pBits) + i * LockedRect.Pitch;
            for (int j = 0;j < colorImg.cols;j++)
            {
                //内部数据是4个字节，0-1-2是BGR，第4个现在未使用
                ptr[3 * j] = pBuffer[4 * j];
                ptr[3 * j + 1] = pBuffer[4 * j + 1];
                ptr[3 * j + 2] = pBuffer[4 * j + 2];
            }
        }
    }
    else
    {
        cout << "捕获彩色图像出错" << endl;
    }

    pTexture->UnlockRect(0);
    NuiImageStreamReleaseFrame(colorStreamHandle, pImageFrame);
}

// 处理深度数据的每一个像素，如果属于同一个用户的ID，那么像素就标为同种颜色，不同的用户，  
// 其ID不一样，颜色的标示也不一样，如果不属于某个用户的像素，那么就采用原来的深度值
BGR Depth2RGB(USHORT depthID)
{
    //每像素共16bit的信息，其中最低3位是ID（所捕捉到的人的ID），剩下的13位才是信息 
    USHORT realDepth = (depthID & 0xfff8) >> 3; //深度信息，高13位
    USHORT player = depthID & 0x0007;   //提取用户ID信息，低3位

                                        //因为提取的信息是距离信息，为了便于显示，这里归一化为0-255
    BYTE depth = (BYTE)(255 * realDepth / 0x1fff);

    BGR color_data;
    color_data.blue = color_data.green = color_data.red = 0;

    color_data.player = player;

    //RGB三个通道的值都是相等的话，就是灰度的  
    //Kinect系统能够处理辨识传感器前多至6个人物的信息，但同一时刻最多只有2个玩家可被追踪（即骨骼跟踪）
    switch (player)
    {
    case 0:
        color_data.blue = depth / 2;
        color_data.green = depth / 2;
        color_data.red = depth / 2;
        break;
    case 1:
        color_data.blue = depth;
        break;
    case 2:
        color_data.green = depth;
        break;
    case 3:
        color_data.red = depth;
        break;
    case 4:
        color_data.blue = depth;
        color_data.green = depth;
        color_data.red = depth / 4;
        break;
    case 5:
        color_data.blue = depth;
        color_data.green = depth / 4;
        color_data.red = depth;
        break;
    case 6:
        color_data.blue = depth / 4;
        color_data.green = depth;
        color_data.red = depth;
        break;
    }

    return color_data;
}

void getDepthImage(HANDLE & depthStreamHandle, cv::Mat & depthImg, cv::Mat & mask)
{
    const NUI_IMAGE_FRAME * pImageFrame = NULL;
    HRESULT hr = NuiImageStreamGetNextFrame(depthStreamHandle, 0, &pImageFrame);
    if (FAILED(hr))
    {
        cout << "Could not get depth image" << endl;
        NuiShutdown();
        return;
    }

    INuiFrameTexture * pTexture = pImageFrame->pFrameTexture;
    NUI_LOCKED_RECT LockedRect;

    pTexture->LockRect(0, &LockedRect, NULL, 0);
    if (LockedRect.Pitch != 0)
    {
        for (int i = 0;i < depthImg.rows;i++)
        {
            uchar * ptr = depthImg.ptr<uchar>(i);
            uchar * ptr_mask = mask.ptr<uchar>(i);

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

            for (int j = 0;j < depthImg.cols;j++)
            {
                // ptr[j] = 255 - (uchar)(255 * pBuffer[j] / 0x0fff);   //直接将数据归一化处理
                // ptr[j] = (uchar)(255 * pBuffer[j] / 0x0fff); //直接将数据归一化处理

                BGR rgb = Depth2RGB(pBuffer[j]);
                ptr[3 * j] = rgb.blue;
                ptr[3 * j + 1] = rgb.green;
                ptr[3 * j + 2] = rgb.red;

                switch (rgb.player)
                {
                case 0:
                    ptr_mask[3 * j] = 0;
                    ptr_mask[3 * j + 1] = 0;
                    ptr_mask[3 * j + 2] = 0;
                    break;
                case 1:
                    ptr_mask[3 * j] = 255;
                    ptr_mask[3 * j + 1] = 0;
                    ptr_mask[3 * j + 2] = 0;
                    break;
                case 2:
                    ptr_mask[3 * j] = 0;
                    ptr_mask[3 * j + 1] = 255;
                    ptr_mask[3 * j + 2] = 0;
                    break;
                case 3:
                    ptr_mask[3 * j] = 0;
                    ptr_mask[3 * j + 1] = 0;
                    ptr_mask[3 * j + 2] = 255;
                    break;
                case 4:
                    ptr_mask[3 * j] = 255;
                    ptr_mask[3 * j + 1] = 255;
                    ptr_mask[3 * j + 2] = 0;
                    break;
                case 5:
                    ptr_mask[3 * j] = 255;
                    ptr_mask[3 * j + 1] = 0;
                    ptr_mask[3 * j + 2] = 255;
                    break;
                case 6:
                    ptr_mask[3 * j] = 0;
                    ptr_mask[3 * j + 1] = 255;
                    ptr_mask[3 * j + 2] = 255;
                    break;
                default:
                    ptr_mask[3 * j] = 0;
                    ptr_mask[3 * j + 1] = 0;
                    ptr_mask[3 * j + 2] = 0;
                    break;
                }
            }
        }
    }
    else
    {
        cout << "捕获深度图像出错" << endl;
    }

    pTexture->UnlockRect(0);
    NuiImageStreamReleaseFrame(depthStreamHandle, pImageFrame);

}

void drawSkeleton(cv::Mat &img, cv::Point pointSet[], int which_one)
{
    cv::Scalar color;
    switch (which_one)
    {
    case 0:
        color = cv::Scalar(255, 0, 0);
        break;
    case 1:
        color = cv::Scalar(0, 255, 0);
        break;
    case 2:
        color = cv::Scalar(0, 0, 255);
        break;
    case 3:
        color = cv::Scalar(255, 255, 0);
        break;
    case 4:
        color = cv::Scalar(255, 0, 255);
        break;
    case 5:
        color = cv::Scalar(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))
        cv::line(img, 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))
        cv::line(img, 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))
        cv::line(img, 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))
        cv::line(img, 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))
        cv::line(img, 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))
        cv::line(img, 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))
        cv::line(img, 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))
        cv::line(img, 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))
        cv::line(img, 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))
        cv::line(img, 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))
        cv::line(img, 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))
        cv::line(img, 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))
        cv::line(img, 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))
        cv::line(img, 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))
        cv::line(img, 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))
        cv::line(img, 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))
        cv::line(img, 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))
        cv::line(img, 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))
        cv::line(img, pointSet[NUI_SKELETON_POSITION_ANKLE_RIGHT], pointSet[NUI_SKELETON_POSITION_FOOT_RIGHT], color, 2);
}

void getSkeletonImage(cv::Mat & skeletonImg, cv::Mat & colorImg)
{
    NUI_SKELETON_FRAME skeletonFrame = { 0 };   //骨骼帧的定义 
    bool foundSkeleton = false;

    HRESULT hr = NuiSkeletonGetNextFrame(0, &skeletonFrame);
    if (SUCCEEDED(hr))
    {
        //NUI_SKELETON_COUNT是检测到的骨骼数（即，跟踪到的人数）
        for (int i = 0;i < NUI_SKELETON_COUNT;i++)
        {
            NUI_SKELETON_TRACKING_STATE trackingState = skeletonFrame.SkeletonData[i].eTrackingState;

            // Kinect最多检测到6个人，但只能跟踪2个人的骨骼，再检查是否跟踪到了
            if (trackingState == NUI_SKELETON_TRACKED)
            {
                foundSkeleton = true;
            }
        }
    }

    if (!foundSkeleton)
    {
        return;
    }

    NuiTransformSmooth(&skeletonFrame, NULL);
    skeletonImg.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;
            // 拿到所有跟踪到的关节点的坐标，并转换为我们的深度空间的坐标，因为我们是在深度图像中  
            // 把这些关节点标记出来的  
            // NUI_SKELETON_POSITION_COUNT为跟踪到的一个骨骼的关节点的数目，为20
            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)
                {
                    cv::circle(skeletonImg, skeletonPoint[i][j], 3, cv::Scalar(0, 255, 255), 1, 8, 0);
                    tracked[i] = true;

                    // 在彩色图中也绘制骨骼关键点
                    LONG color_x, color_y;
                    NuiImageGetColorPixelCoordinatesFromDepthPixel(NUI_IMAGE_RESOLUTION_640x480, 0,
                        skeletonPoint[i][j].x, skeletonPoint[i][j].y, 0, &color_x, &color_y);
                    colorPoint[i][j].x = (int)color_x;
                    colorPoint[i][j].y = (int)color_y;
                    cv::circle(colorImg, colorPoint[i][j], 4, cv::Scalar(0, 255, 255), 1, 8, 0);
                }
            }

            drawSkeleton(skeletonImg, skeletonPoint[i], i);
            drawSkeleton(colorImg, colorPoint[i], i);
        }
    }

}

结果

png

png

png

（由于有我同学的照片，所以打了码）

参考资料

  1. https://blog.csdn.net/zouxy09/article/details/8163265
  2. https://blog.csdn.net/timebomb/article/details/7169372
hongbin_xu
关注
  • 5
    点赞
  • 踩
  • 35
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
专栏目录
关于Kinect根据深度图对齐彩色图抠人比彩色图像人大的问题
清风似水流的专栏
08-08 5052
我根据Kinect自带的那个绿色抠人Demo，大家有没有发现抠出来的人比彩色图像中人变大了，该Demo是根据一个函数NuiImageGetColorPixelCoordinateFrameFromDepthPixelFrameAtResolution来对齐，导致我根据帧差法得到的前景图无法与抠出人的大小对齐，因此无法修复抠出来人边缘的抖动。下面，我介绍一个函数MapColorFrameToDept
Kinect开发学习笔记之（四）提取颜色数据并用OpenCV显示
zouxy09的专栏
11-04 4万+
Kinect开发学习笔记之（四）提取颜色数据并用OpenCV显示 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/zo
Kinect+OpenNI学习笔记之2(获取kinect的颜色图像和深度图像)
cgy8919的博客
01-29 522
　　前言 　　网上有不少使用Qt做界面，OpenNI为库来开发kinect。或许大家的第一个问题就是询问该怎样使用Kinect来获取颜色信息图和深度信息图呢？这一节就是简单来回答这个问题的。 　　开发环境：QtCreator2.5.1+OpenNI1.5.4.0+Qt4.8.2   　　实验说明： 　　在使用OpenNI来驱动读取kinect数据时，我们需要了解context objec...
深度图像分割：利用mask对原图中的分割对象进行分割出来
Major_S的博客
05-21 2635
from PIL import Image import numpy as np subimage = Image.open('res.jpg') original = Image.open(img_path) original = original.resize((320, 320)) subimage = np.array(subimage) original = np.array(original) for i in range(320): for j in range(320):
Kinect获取的人体骨架中的25点
iamjingong的博客
07-16 5556
 
Kinect开发学习笔记之（七）骨骼数据的提取
热门推荐
zouxy09的专栏
11-08 10万+
Kinect开发学习笔记之（七）骨骼数据的提取 zouxy09@qq.com http://blog.csdn.net/zouxy09   我的Kinect开发平台是： Win7x86 + VS2010 + Kinect for Windows SDK v1.6 + OpenCV2.3.0 开发环境的搭建见上一文： http://blog.csdn.net/zouxy09/arti
OpenNI学习笔记1-获取kinect的颜色图像和深度图像
SingDancer的专栏
08-09 937
获取kinect的颜色图像和深度图像
使用kinect2.0做动作识别和重量颜色识别
Enigma_tong的博客
01-06 717
在抓取杠铃的过程中，杠铃的颜色是固定的，我们可以使用颜色信息识别出我们杠铃片的重量，具体做法是，利用手抓取横杆的信息获取到手的骨骼关键点的深度值信息，然后利用距离信息做x,y,z方向上的点云滤除，滤除完以后的图片映射回彩色图如图所示： 这时候我们再利用opencv做图像的腐蚀运算，然后提取blob信息，分割，提取最大轮廓，分离出杠铃。再把RGB图像转化为HSV图像，做各个色彩通道的分离，色彩通道分离的python代码在这里： import cv2 import numpy as np # 滑动条的回调函数
读取并显示kinect彩色和深度信息的三种方式：代码
05-30
标题中的“读取并显示kinect彩色和深度信息的三种方式：代码”表明，这篇内容主要探讨了如何使用C++编程语言从微软的Kinect设备中获取并展示色彩与深度数据。Kinect是一款用于捕捉人体运动和环境信息的外设，广泛...
深度图像提取骨骼序列代码
04-26
"深度图像提取骨骼序列代码"这个项目显然关注的是如何从RGBD（红绿蓝深度）图像中获取人体骨架的动作序列。下面将详细阐述相关知识点。 1. **RGBD图像**：RGBD图像结合了传统的RGB彩色图像与深度信息，能够提供物体...
opencv显示kinect深度彩色骨架数据
07-02
在OpenCV库中处理Kinect设备的深度和骨架数据是一项常见的任务，特别是在计算机视觉...在实际操作时，参考提供的"Kinect_SDK1.0_OpenCV显示彩色、深度、骨骼图.doc"文档会非常有帮助，它应包含了详细的步骤和代码示例。
Kinect+QT+openCV 读取Kinect彩图、深度图
03-10
标题中的“Kinect+QT+openCV 读取Kinect彩图、深度图”涉及到的是一个集成技术的应用，主要是利用微软的Kinect设备，通过Qt图形界面库和OpenCV计算机视觉库来显示并处理Kinect获取的彩色图像（彩图）和深度图像。...
基于深度视觉数据的人机交互系统，程序源码，word论文，讲解PPT
04-01
首先通过Kinect体感摄像机采集深度信息和人体骨骼数据，然后利用计算机视觉的相关知识处理信息，从而完成用户和计算机之间的互动。关于深度数据的采集，Kinectv2采用的是飞行时间测距技术，相比v1，精度提高，效果更...
Kinect学习（六）：提取人体关节点数据
hongbin_xu的博客
07-03 1万+
前言 Kinect可以通过处理深度数据来得到人体各个关节点的位置坐标，比如：头、手、脚等等。下面是人体的20个关节点的示意图： 这篇学习笔记的目标就是通过Kinect获取人体的骨骼点数据。 代码 #include &amp;amp;lt;Windows.h&amp;amp;gt; #include &amp;amp;lt;iostream&amp;amp;gt; #include &amp;amp;lt;NuiApi.h&amp;amp;gt;
Kinect Azure DK获取深度图、深度数据和人体骨骼关键点三维坐标
qq_42012733的博客
06-03 7989
文章目录 一、获取深度图 二、获取深度数据 三、获取人体骨骼关键点三维坐标
kinect 2获取数据流程介绍（强烈推荐入门新手）
weixin_44063985的博客
05-27 7254
原文链接： Kinect V2开发（2）从Kinect获取数据   在Kinect for windows SDK2.0中，Kinect有多种类型的数据源，每个类型的数据都有三个类与之对应：Source，Reader和Frame。例如，要读取骨架，就有IBodyFrameSource, IBodyFrameReader, IBodyFrame这三个类，要读取深度数据，就有IDepthFrameSo...
kinect获取的20个骨骼点坐标
u012686173的专栏
10-20 7800
if (skeleton.TrackingState == SkeletonTrackingState.Tracked)                             {                                 float[] showHead = new float[]{skeleton.Joints[JointType.Head].Position.X,
Kinect for windows 开发入门 九：骨骼数据获取和使用
Kinector的专栏
08-22 4088
背景知识 1.  骨骼追踪：骨骼追踪技术通过处理景深数据来建立人体各个关节的坐标,骨骼追踪能够确定人体的各个部分，如那部分是手，头部，以及身体。在Kinect里面，是通过20个关节点来表示一个骨架的，具体由下图可以看到。当你走进Kinect的视野范围的时候，Kinect就可以把你的20个关节点的位置找到（当然你得站着），位置通过(x, y, z)坐标来表示。SkeletonStream产生的
Kinect学习（一）：开发环境搭建
hongbin_xu的博客
06-20 2万+
前言 当初刚进大学时买了一台Xbox 360，为了玩体感游戏另外还买了一个Kinect
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值