同时获得深度/彩色/骨骼

最新推荐文章于 2022-01-05 16:29:38 发布
最新推荐文章于 2022-01-05 16:29:38 发布
阅读量177 收藏
点赞数
分类专栏： kinect-3d
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25254777/article/details/78667001
版权 
#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;
            }
        }
    }
}
城墙郭外斜
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Kinect_SDK1.0_OpenCV显示彩色、深度、骨骼图
03-07
Kinect_SDK1.0_OpenCV显示彩色、深度、骨骼图
基于C++实现kinect+opencv 获取深度及彩色数据
09-03
本文的主要思想是Kinect SDK 读取彩色、深度、骨骼信息并用OpenCV显示，非常的实用，有需要的小伙伴可以参考下
Kinect开发学习笔记之（八）彩色、深度、骨骼和用户抠图结合
zouxy09的专栏
11-08 2万+
Kinect开发学习笔记之（八）彩色、深度、骨骼和用户抠图结合 [email protected] http://blog.csdn.net/zouxy09   我的Kinect开发平台是： Win7 x86 + VS2010 + Kinect for Windows SDK v1.6 + OpenCV2.3.0 开发环境的搭建见上一文： http://blog.csdn.net/zou
kinect 读取彩色、深度、骨骼信息
weixin_43154360的博客
05-24 1073
配置Kinect 1、基本设置 能够连接Kinect需先安装其官方控件 https://pan.baidu.com/s/10hA-hDb8S-WivEhCtpe45w 提取码：5ncv 有需要的自取吧~ 其中大概如下： KinectDeveloperToolkit-v1.8.0-Setup+KinectSDK-v1.8-Setup+OpenCV-2.3.1-win-superpack（必备） 在...
深度学习知识点全面总结
热门推荐
专注大数据与人工智能技术分享，欢迎私信加群互相学习！
01-05 21万+
本文详细介绍深度学习概念及原理，参考网上相关资料汇总，内容包含众多章节，包括神经网络基础及常见深度学习网络结构介绍，用于个人学习总结，适合深度学习初学者学习。同时介绍机器学习常见的分类算法：SVM、神经网络、随机森林、逻辑回归、KNN、贝叶斯。常见的监督学习算法：感知机、SVM、人工神经网络、决策树、逻辑回归.........
ROS下同时存储Kinect 深度和RGB图
熊猫飞天
03-10 5435
用深度相机构图做SLAM 常需要对一个真实的环境进行测试，需要自己使用深度相机录制数据集。通常相机的硬件商或者是网上都有深度相机在ROS下的驱动程序，使得我们可以正常的通过单个topic 看到深度图像和彩色图像，但是我们经常卡在如何使用一个ROS节点接收多个topic 的数据这个步骤，解决这个问题需要使用ROS 自带的多线程创建工具（ros::AsyncSpinner）。 注：环境平台为： Ubu...
Kinect骨骼数据与彩色影像和深度影像的对齐
King-Blog
12-15 1723
很多同学留言问怎么讲两种影像数据显示在同一张屏幕上，也就是说怎么将骨骼数据叠加到彩色影像或者深度影像上，将彩色影像叠加到深度影像就不讨论了，因为没啥意义。     这个问题其实很简单，因为在Kinect Developer Toolkit中很多例子中又可以看到这两种类型的叠加，而源代码也都有，这也是为啥我不想将这个的原因。怎么将这三种影像显示在屏幕上我在第三讲：基础知识 下、第四讲：景深
kinect linux 深度处理,kinect彩色图和深度图对齐(一)
weixin_42134338的博客
05-14 1990
本文主要记录kinect相关的知识和对齐方法，这是第一部分，此记。深度相机成像方法简介深度相机就是可以获取场景中物体距离摄像头物理距离的相机。深度相机通常由多种镜头和光学传感器组成，根据测量原理不同，主流的深度相机一般分为以下几种方法：飞行时间法(ToF)、结构光法、双目立体视觉法。飞行时间是从Time of Flight直译过来的，简称TOF。其测距原理是通过连续发射经过调制的特定频率的光脉冲(...
Kinect学习（七）：综合提取彩色、深度、人体骨骼点
hongbin_xu的博客
07-04 4847
前言 前面的博客中介绍了如何通过Kinect获得彩色图像、深度图像以及人体骨骼点： Kinect学习（三）：获取RGB颜色数据 Kinect学习（四）：提取深度数据 Kinect学习（五）：提取带用户ID的深度数据 Kinect学习（六）：提取人体关节点数据 这次要将这几者综合起来，同时从Kinect那里拿来这些数据。 代码 这里的代码只是将前面几篇博客中的内容整合了一下，就不做过多...
Kinect SDK(1)：读取彩色、深度、骨骼信息并用OpenCV显示
aikb6223的博客
04-24 412
Kinect SDK读取彩色、深度、骨骼信息并用OpenCV显示 一、原理说明 对于原理相信大家都明白大致的情况，因此，在此只说比较特别的部分。 1.1 深度流数据： 深度数据流所提供的图像帧中，每一个像素点代表的是在深度感应器的视野中，该特定的（x, y）坐标处物体到离摄像头平面最近的物体到该平面的距离， 注意是平面到平面距离，...
Kinect彩色相机与深度相机的标定与配准
02-15
Kinect彩色相机与深度相机的标定与配准，何富多，胡燕祝，Kinect能够获取空间中的人体骨骼节点的三维坐标，对于研究人体动作识别具有重大的意义。本文意在通过对Kinect相机的标定获取其相机的
2010中基于MFC实现Kinect彩色和深度及骨骼数据显示
10-11
我的实现环境是在visual studio 2010中基于对话框进行的实现。 （1）实现了对深度图、彩色图及骨骼图映射到深度图中； （2）图形数据和显示绘制分离；
读取并显示Kinect彩色图和深度图的三种方法：代码
04-20
Kinect有三个数据流：彩色图，深度图和骨骼点。KinectSDK是利用三个数据流返回的句柄读取对应信息。 KinectSDK+OpenCV的方法详细内容可以参照博客：http://blog.csdn.net/yangtrees/article/details/16106271 利用...
基于TC72（SPI接口）温度传感器、STM32F103C8T6、LCD1602、FREERTOS的温度采集proteus仿真
05-21
spi
ehcache-core-2.6.9.jar
05-21
javaee/javaweb常用jar包，亲测可用，导入到java工程中即可使用
netty-transport-native-unix-common-4.1.51.Final.jar
05-21
javaEE javaweb常用jar包 ， 亲测可用，下载后导入到java工程中使用。
node-v6.14.4-headers.tar.xz
最新发布
05-21
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
KinectopenCV 读取Kinect彩图、深度图
03-27
Kinect是一种基于红外线技术的体感设备，可以捕捉人体骨骼信息、彩色图像和深度图像等数据。而OpenCV是一个开源计算机视觉库，用于处理图像和视频数据。 在使用Kinect进行人体姿态识别等应用时，通常需要读取Kinect...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

城墙郭外斜

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值