simple blob detection with kinect SDK

Question

as far as I understand the official Kinect 1.5 SDK, it comes with Face Tracking and Skeleton Tracking. How about simple blob detection? All I want to do, is to track a round / elliptic object. I can't find any code for that in the SDK, so should I use opencv or some other library for that?

(my code is in c++)

EDIT1 is it possible to tune the face tracker so it would detect round shapes in general (instead of faces)?

EDIT2 here's depth processing code from an example shipped with the SDK. How do I get OpenCV to extract a blob from it?

void CDepthBasics::ProcessDepth()
{
    HRESULT hr;
    NUI_IMAGE_FRAME imageFrame;

    // Attempt to get the depth frame
    hr = m_pNuiSensor->NuiImageStreamGetNextFrame(m_pDepthStreamHandle, 0, &imageFrame);
    if (FAILED(hr))
    {
        return;
    }

    INuiFrameTexture * pTexture = imageFrame.pFrameTexture;
    NUI_LOCKED_RECT LockedRect;

    // Lock the frame data so the Kinect knows not to modify it while we're reading it
    pTexture->LockRect(0, &LockedRect, NULL, 0);

    // Make sure we've received valid data
    if (LockedRect.Pitch != 0)
    {
        BYTE * rgbrun = m_depthRGBX;
        const USHORT * pBufferRun = (const USHORT *)LockedRect.pBits;

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

        while ( pBufferRun < pBufferEnd )
        {
            // discard the portion of the depth that contains only the player index
            USHORT depth = NuiDepthPixelToDepth(*pBufferRun);

            // to convert to a byte we're looking at only the lower 8 bits
            // by discarding the most significant rather than least significant data
            // we're preserving detail, although the intensity will "wrap"
            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;

            // We're outputting BGR, the last byte in the 32 bits is unused so skip it
            // If we were outputting BGRA, we would write alpha here.
            ++rgbrun;

            // Increment our index into the Kinect's depth buffer
            ++pBufferRun;

        }

        // Draw the data with Direct2D
        m_pDrawDepth->Draw(m_depthRGBX, cDepthWidth * cDepthHeight * cBytesPerPixel);
    }

    // We're done with the texture so unlock it
    pTexture->UnlockRect(0);

    // Release the frame
    m_pNuiSensor->NuiImageStreamReleaseFrame(m_pDepthStreamHandle, &imageFrame);
}

George Profenza George Profenza · Accepted Answer · 2012-09-21T11:29:40

Once you've got the image you need from the Kinect feel free to use any image processing library with the result.

You can use OpenCV's Hough Circle Transform to detect circles. You might need to convert from the Kinect image format to cv::Mat first.

I imagine OpenCV is not the only library with that functionality. If you're interested, lookup Hough Transforms in general.

I don't think tuning the face tracker is the way to go though.

simple blob detection with kinect SDK

2 Answers