Question

I use the following c++ code to read out the depth information from the kinect:

    BYTE * rgbrun = m_depthRGBX;
    const USHORT * pBufferRun = (const USHORT *)LockedRect.pBits;

    // end pixel is start + width*height - 1
    const USHORT * pBufferEnd = pBufferRun + (Width * Height);

    // process data for display in main window.
    while ( pBufferRun < pBufferEnd )
    {
        // discard the portion of the depth that contains only the player index
        USHORT depth = NuiDepthPixelToDepth(*pBufferRun);

        BYTE intensity = static_cast<BYTE>(depth % 256);


        // Write out blue byte
        *(rgbrun++) = intensity;

        // Write out green byte
        *(rgbrun++) = intensity;

        // Write out red byte
        *(rgbrun++) = intensity;

        ++rgbrun;

        ++pBufferRun;

    }

What I’d like to know is, what is the easiest way to implement frame flipping (horizontal & vertical)? I couldn’t find any function in the kinect SDK, but maybe I missed it?

EDIT1 I’d like to not having to use any external libraries, so any solutions that explain the depth data layout and how to invert rows / columns, is highly appreciated.

Answer 1

So, you’re using a standard 16bpp single channel depth map with player data. This is a nice easy format to work with. An image buffer is arranged row-wise, and each pixel in the image data has the bottom 3 bits set to the player ID and the top 13 bits set to depth data.

Here’s a quick’n’dirty way to read each row in reverse, and write it out to an RGBWhatever image with a simple depth visualisation that’s a little nicer to look at that the wrapping output you currently use.

BYTE * rgbrun = m_depthRGBX;
const USHORT * pBufferRun = (const USHORT *)LockedRect.pBits;

for (unsigned int y = 0; y < Height; y++)
{
    for (unsigned int x = 0; x < Width; x++)
    {
        // shift off the player bits
        USHORT depthIn = pBufferRun[(y * Width) + (Width - 1 - x)] >> 3;

        // valid depth is (generally) in the range 0 to 4095.
        // here's a simple visualisation to do a greyscale mapping, with white
        // being closest. Set 0 (invalid pixel) to black.
        BYTE intensity = 
            depthIn == 0 || depthIn > 4095 ?
                0 : 255 - (BYTE)(((float)depthIn / 4095.0f) * 255.0f);

        *(rgbrun++) = intensity;
        *(rgbrun++) = intensity;
        *(rgbrun++) = intensity;
        ++rgbrun;
    }
}

Code untested, E&OE, etc 😉

It is possible to parallelise the outer loop, if instead of using a single rgbrun pointer you get a pointer to the beginning of the current row and write the output to that instead.