Amit Puri's blog

Setup Kinect sensor object to retrieve first available sensor, other variables to hold color pixel data and a writeable bitmap object to write pixel onto it.

KinectSensor sensor = KinectSensor.KinectSensors[0];
private byte[] colorPixelData;
private WriteableBitmap outputImage;

Add enabling color stream in MainWindow() constructor of Main.Window.xaml, using sensor object, enable color stream, also setting up rgb resolution to 
640x480 at the 30 frames per seconds(FPS). Add color frame ready handler so that color frame stream can be handled appropriately. And invoke Start method 
of sensor to start the sensor, which will actually start receiving streams from the sensor.

sensor.ColorStream.Enable(ColorImageFormat.RgbResolution640x480Fps30);
sensor.ColorFrameReady += new EventHandler<ColorImageFrameReadyEventArgs>(sensor_ColorFrameReady);
sensor.Start();

Color Image formats on MSDN

Add color frame ready handler,which will invoke as sensor starts receiving color frame includes arg e, which can be used to open the color image frame, 
CopyPixeDataTo the colorPixelData byte array declared earlier, use WriteableBitmap for desired width and height of the bitmap, horizontal and vertical 
dots per inch of the bitmap, PixelFormat and null bitmap palette.later use WritePixels method to update the pixels in the specified region of the bitmap, 
create a rectangle using 0,0, width and height of the color frame, using colorPixelData for input buffer used for updating bitmap, size of the buffer 
and stride, which is 0, and finally assign outputImage to the source of image control named kinectColorImage.

      void sensor_ColorFrameReady(object sender, ColorImageFrameReadyEventArgs e)
        {
            using (ColorImageFrame colorFrame = e.OpenColorImageFrame())
            {
                if (colorFrame != null)
                {
                    //Using standard SDK
                    this.colorPixelData = new byte[colorFrame.PixelDataLength];

                    colorFrame.CopyPixelDataTo(this.colorPixelData);

                    this.outputImage = new WriteableBitmap(
                    colorFrame.Width,
                    colorFrame.Height,
                    96,  // DpiX
                    96,  // DpiY
                    PixelFormats.Bgr32,
                    null);

                    this.outputImage.WritePixels(
                    new Int32Rect(0, 0, colorFrame.Width, colorFrame.Height),
                    this.colorPixelData,
                    colorFrame.Width * 4,
                    0);
                    this.kinectColorImage.Source = this.outputImage;

                    //Using Coding4Fun Kinect Toolkit
                    //kinectColorImage.Source = imageFrame.ToBitmapSource();

                }
            }
          }

or, in case you want to use Code4fun Kinect toolkit, install it via NuGet Install-Package Coding4Fun.Kinect.Wpf and use ToBitmapSource() method to do the same stuff. Happy Kinecting!!!

Kinect for Windows SDK–Depth stream

Amit Puri — Mon, 16 Apr 2012 07:58:00 GMT

Depth Stream in WPF Application

Add Image control in MainWindow.xaml in the Window grid

<Image Name="kinectDepthImage" />

KinectSensor sensor = KinectSensor.KinectSensors[0];
private short[] depthPixelData;
private byte[] depthFrame32;
private WriteableBitmap outputBitmap;

Add enabling depth stream in MainWindow() constructor of Main.Window.xaml

sensor.DepthStream.Enable(DepthImageFormat.Resolution640x480Fps30);
sensor.DepthFrameReady += new EventHandler<DepthImageFrameReadyEventArgs>(sensor_DepthFrameReady);
sensor.Start();

Add Depth frame ready handler

void sensor_DepthFrameReady(object sender, DepthImageFrameReadyEventArgs e)
{

    using (DepthImageFrame depthFrame = e.OpenDepthImageFrame())
    {
        if (depthFrame != null)
        {
            //Using standard SDK this.depthPixelData = new short[depthFrame.PixelDataLength];
            this.depthFrame32 = new byte[depthFrame.Width * depthFrame.Height * 4];
            depthFrame.CopyPixelDataTo(this.depthPixelData);
            byte[] convertedDepthBits = this.ConvertDepthFrame(this.depthPixelData, ((KinectSensor)sender).DepthStream);

            this.outputBitmap = new WriteableBitmap(
                    depthFrame.Width,
                    depthFrame.Height,
                    96,  // DpiX 96,  // DpiY PixelFormats.Bgr32,
                    null);

            this.outputBitmap.WritePixels(
                new Int32Rect(0, 0, depthFrame.Width, depthFrame.Height),
                convertedDepthBits,
                depthFrame.Width * 4,
                0);

            this.kinectDepthImage.Source = this.outputBitmap;

            //Using Coding4Fun Kinect Toolkit ////turn raw data into an array of distances; //var depthArray = depthFrame.ToDepthArray(); ////image //kinectDepthImage.Source = depthFrame.ToBitmapSource(); }
    }

}

// color divisors for tinting depth pixels private static readonly int[] IntensityShiftByPlayerR = { 1, 2, 0, 2, 0, 0, 2, 0 };
private static readonly int[] IntensityShiftByPlayerG = { 1, 2, 2, 0, 2, 0, 0, 1 };
private static readonly int[] IntensityShiftByPlayerB = { 1, 0, 2, 2, 0, 2, 0, 2 };

private const int RedIndex = 2;
private const int GreenIndex = 1;
private const int BlueIndex = 0;

// Converts a 16-bit grayscale depth frame which includes player indexes into a 32-bit frame // that displays different players in different colors private byte[] ConvertDepthFrame(short[] depthFrame, DepthImageStream depthStream)
{
    int tooNearDepth = depthStream.TooNearDepth;
    int tooFarDepth = depthStream.TooFarDepth;
    int unknownDepth = depthStream.UnknownDepth;

    for (int i16 = 0, i32 = 0; i16 < depthFrame.Length && i32 < this.depthFrame32.Length; i16++, i32 += 4)
    {
        int player = depthFrame[i16] & DepthImageFrame.PlayerIndexBitmask;
        int realDepth = depthFrame[i16] >> DepthImageFrame.PlayerIndexBitmaskWidth;

        // transform 13-bit depth information into an 8-bit intensity appropriate // for display (we disregard information in most significant bit) byte intensity = (byte)(~(realDepth >> 4));

        if (player == 0 && realDepth == 0)
        {
            // white this.depthFrame32[i32 + RedIndex] = 255;
            this.depthFrame32[i32 + GreenIndex] = 255;
            this.depthFrame32[i32 + BlueIndex] = 255;
        }
        else if (player == 0 && realDepth == tooFarDepth)
        {
            // dark purple this.depthFrame32[i32 + RedIndex] = 66;
            this.depthFrame32[i32 + GreenIndex] = 0;
            this.depthFrame32[i32 + BlueIndex] = 66;
        }
        else if (player == 0 && realDepth == unknownDepth)
        {
            // dark brown this.depthFrame32[i32 + RedIndex] = 66;
            this.depthFrame32[i32 + GreenIndex] = 66;
            this.depthFrame32[i32 + BlueIndex] = 33;
        }
        else {
            // tint the intensity by dividing by per-player values this.depthFrame32[i32 + RedIndex] = (byte)(intensity >> IntensityShiftByPlayerR[player]);
            this.depthFrame32[i32 + GreenIndex] = (byte)(intensity >> IntensityShiftByPlayerG[player]);
            this.depthFrame32[i32 + BlueIndex] = (byte)(intensity >> IntensityShiftByPlayerB[player]);
        }
    }

    return this.depthFrame32;
}

Kinect for Windows SDK - NUI - SDK Architecture

Amit Puri — Thu, 09 Feb 2012 04:13:00 GMT

The Kinect for Windows SDK provides the tools and APIs, both native and managed to develop Kinect-enabled applications for Microsoft Windows. Developing Kinect-enabled application includes additional NUI processing support for color images, depth images, audio input, and skeletal data.

Kinect for Windows Architecture

Playing with “Kinect for Windows SDK” Series

Amit Puri — Fri, 13 Jan 2012 15:39:00 GMT

<>

I have been playing with Kinect for Windows SDK from last few weeks. It’s really a fun. With several things happening on Kinect, apart from Xbox gaming and Entertainment, Kinect is coming out from Living room, check out The Kinect Effect, announcement on Kinect for Windows commercially available Starting February 1, 2012: Use the Power of Kinect for Windows to Change the World and The Kinect Accelerator on Microsoft BizSpark.

I really got excited to explore SDK.

What you need to begin - Kinect Sensor, USB powered cable for Kinect Sensor and Kinect for Windows SDK beta 2. I recommend Understanding Kinect Hardware on channel 9.

This week in this series, I am covering how to get started with Kinect for Windows SDK

Start a new WPF Application Project using Visual Studio 2010
Add reference Microsoft.Research.Kinect.dll from "%KINECTSDK_DIR%\Assemblies"
Add using directive in MainWindow.xaml
using Microsoft.Research.Kinect.Nui;
Declare Runtime variable named nui in MainWindow class level
Runtime nui;
Add Window_Loaded event handler for MainWindow
if (Runtime.Kinects.Count > 0)
{
nui = Runtime.Kinects[0];
nui.Initialize(RuntimeOptions.UseColor);
}
Add StatusChanged
Runtime.Kinects.StatusChanged += new EventHandler<StatusChangedEventArgs>(Kinects_StatusChanged);
Define Kinects_StatusChanged
void Kinects_StatusChanged(object sender, StatusChangedEventArgs e)
        {
            switch (e.Status)
            {
                case KinectStatus.Connected:
                    nui = e.KinectRuntime;
                    nui.Initialize(RuntimeOptions.UseColor);
                    break;
                case KinectStatus.Disconnected:
                    //handle what to do when disconnected
                    break;
                case KinectStatus.Error:
                    //handle what to do when error
                    break;
                case KinectStatus.NotPowered:
                    //handle what to do when not powered
                    break;
                case KinectStatus.NotReady:
                    //handle what to do when not ready
                    break;
                default:
                    break;

            }
        }
Add Window closed handler for MainWindow

              private void Window_Closed(object sender, EventArgs e)
        {
            if (nui!=null)
            {
                nui.Uninitialize();
            }

        }

Let us also see how Kinect Camera can be tilted.

Added two buttons Up and Down Tilt in MainWindow and Click handler for button to Tilt Camera up and down.

private void TiltUp_Click(object sender, RoutedEventArgs e)
{
if ((nui.NuiCamera.ElevationAngle)<=Camera.ElevationMaximum)
{
   if ((nui.NuiCamera.ElevationAngle+4)>=Camera.ElevationMaximum)
   {
    nui.NuiCamera.ElevationAngle = Camera.ElevationMaximum;
   }
   else
   {
   nui.NuiCamera.ElevationAngle += 4;
   }
}
}

private void TiltDown_Click(object sender, RoutedEventArgs e)
{
if ((nui.NuiCamera.ElevationAngle)>= Camera.ElevationMinimum)
{
    if ((nui.NuiCamera.ElevationAngle - 4) <= Camera.ElevationMinimum)
    {
    nui.NuiCamera.ElevationAngle = Camera.ElevationMinimum;
    }
    else
    {
    nui.NuiCamera.ElevationAngle -= 4;
    }
}
}

and Run it, and try Tilt up and down…

Warning: The tilt mechanism in the sensor array is not rated for frequent use. You should tilt the Kinect sensor as few times as possible, to minimize wear on the camera and to minimize tilting time. The camera motor is not designed for constant or repetitive movement, and attempts to use it that way may cause degradation of motor function. Source Readme for Kinect for Windows SDK - Beta 2 release

Kinect for Windows on Social

Facebook, Twitter, Blog and Resources on Microsoft.com

Next article in the series talks about Kinect Skeleton tracking. Stay tuned...

WpfKinectQuickStarter.zip