The next thing you need to do is add the Kinect libraries to the Visual Studio project using the following steps:

We now have a default project ready with the Kinect library added. The next thing to do is to access the library APIs for our application.

In a Kinect application, each Kinect device represents an instance of the Microsoft.Kinect.KinectSensor class. This represents the complete runtime pipeline for the sensor during the life span of the application.

The following diagram illustrates the usage of Kinect sensors over a life span of an application:

Defining the sensor objects is as simple as defining other class objects. The defined object will come into action only when you initialize for a specific Kinect operation, such as color image streaming and depth image streaming. We can define a Kinect sensor object using the following code snippet:

public partial class MainWindow : Window
{
 KinectSensor sensor;
    // remaining code goes here
}

The sensor objects need a reference to the Kinect device that is connected with the system and can be used by your application. You can't instantiate the KinectSensor object as it does not have a public constructor. Instead, the SDK creates KinectSensor objects when it detects a Kinect device attached to your system.

The KinectSensor class has a static property of the KinectSensorCollection type, named KinectSensors, which consists of the collection of sensors that are connected with your system. The KinectSensor.KinectSensors collection returns the collection of Kinect devices connected with your system. KinectSensorCollection is a read-only collection of the KinectSensor type. Each KinectSensorCollection class consists of an indexer of the KinectSensor object and an event named StatusChanged. The following code block shows the definition of the KinectSensorCollection class:

public sealed class KinectSensorCollection : ReadOnlyCollection<KinectSensor>, IDisposable
    {
        public KinectSensor this[string instanceId] { get; }
        public event EventHandler<StatusChangedEventArgs>StatusChanged;

        public void Dispose();
    }

As this returns a collection of Kinect devices, you can use any index of that collection to get the reference of a particular sensor. As an example, if you have two devices connected with your system, KinectSensor.KinectSensors[0] will represent the first Kinect device and KinectSensor.KinectSensors[1] will represent the second Kinect device.

Consider that you have connected a device, so you will get a reference of this connected sensor as shown in this code:

this.sensor = KinectSensor.KinectSensors[0];

Once you have the sensor object for the Kinect device, invoke the KinectSensor.Start() method to start the sensor.

int deviceCount = KinectSensor.KinectSensors.Count;
if (deviceCount > 0)
{
    this.sensor = KinectSensor.KinectSensors[0];
    // Rest operation here 
}
else
{
    // No sensor connected. Take appropriate action
}

Before taking any further action, the sensor.Start() method first checks for the status of the sensor(with the Status term). The initialization of the sensor happens only if the sensor is connected. If the sensor is not connected and you are trying to start the sensor, it will throw an InvalidOperationException object with the KinectNotReady message.

If the sensor is connected, the Start() method initializes the sensor and then tries to open the color, depth, and skeleton data stream channels with the default values if they are set to Enable.

The initialization of the sensor happens with a set of enumeration flags, which provides the type of channel that needs to be initialized. The following table lists the types of initialization options and their descriptions:

The initialization of the stream channel is achieved by setting the options internally. From a developer's perspective, you just need to call the Start() method, and the rest will be taken care of by the SDK.

The KinectSensor class provides specific events that help to enable and to subscribe image stream, depth stream, and skeleton stream data. We will be dealing with details of each and every data stream in subsequent chapters. As of now, we will learn how to enable stream data in our application.

Within the Kinect for Windows SDK, the color, depth, and skeleton data streams are represented by the types of ColorImageStream, DepthImageStream, and SkeletonStream methods respectively. Each of them has an Enable method that opens up the stream pipeline. For example, to enable the ColorStream type, you need to write the following line of code:

this.sensor.ColorStream.Enable();

You can explicitly enable the stream only after the StartSensor() method, as shown in the following code snippet. In our Info Box application, we did the same by enabling the color, depth, and skeleton data streams after starting the sensor.

if (KinectSensor.KinectSensors.Count > 0)
{
    this.sensor = KinectSensor.KinectSensors[0];
    this.StartSensor();
 this.sensor.ColorStream.Enable();
 this.sensor.DepthStream.Enable();
 this.sensor.SkeletonStream.Enable();
}

If you know the device connection ID for your Kinect sensor, you can use the same for instantiating the senor instead of using an index. This will make sure that you are initializing the correct device if there are multiple devices and if you are not sure about the device index. In the following code snippet we have used the previously received unique instance ID:

KinectSensor  sensor = KinectSensor.KinectSensors [@" USB\VID_045E&PID_02C2\5&192B533&0&5"];
This.sensor.Start()

As this Connection ID returns the USB hub device instance path ID, it will be changed once you plug the device into a different USB hub.

If you are aware of your device ID, you can always refer to the device using the ID as stated in the following code block:

KinectSensor sensor = KinectSensor.KinectSensors[@"USB\VID_045E&PID_02AE\A00362A01385118A"];
int position = 0;
var collection = KinectSensor.KinectSensors.Where(item => item.DeviceConnectionId == sensor.DeviceConnectionId);
var indexCollection = from item in collection
let row = position++
select new { SensorObject = item, SensorIndex = row };

If it's a single sensor, the index should be 0, but this code block will return the actual position from the list of sensors as well. Currently, we have tested the code with one sensor, so we have the sensor index value 0 as shown in the following screenshot:

It's good practice to call Stop() once you are done with the Kinect sensor. This is because the Stop() method does some clean-up work internally before it actually shuts down the device. It completes the following tasks:

The following diagram shows the actual flow of the Stop() method of a Kinect device:

The Kinect sensor internally uses unmanaged resources to manage the sensor data streams. It sends the stream to the managed application and the KinectSensor class uses it. When we close the application, it cannot dispose of the unmanaged stream automatically if we don't forcefully send a termination request by calling the Stop() method. The managed Dispose method does this as well. So to turn off the device, the application programmer needs to call the Stop() method to clear unmanaged resources before the managed application gets closed.

For instance, if you are running the application while debugging, your application will be directly hosted in your vshost file and the Visual Studio debugger allows you to run your code line by line. If you close the application directly from Visual Studio, it will ensure that the process gets stopped without any code getting executed. To experience this situation, you can stop the application directly from Visual Studio without calling the Stop() method, and you will see the IR light of the device is still on.

This application displays information using the System.Windows.Controls.TextBlock class inside a System.Windows.Controls.Grid class. That is, each cell on the grid contains a Textblock component. The following excerpt from the MainWindow.xaml file shows how this is accomplished in XAML:

<TextBlock Text="Connection ID" Grid.Row="1" Grid.Column="0" 
Style="{StaticResource BasicTextStyle}"  />
<TextBlock Text="{Binding ConnectionID}" Grid.Row="1" Grid.Column="1"
Style="{StaticResource BasicContentStyle}" />

As we are going to display the information in text format, we will be splitting the window into a number of columns and rows, where each of the individual rows is responsible for showing information for one single sensor. As you can see in the preceding code, we have two TextBlock controls. One of them shows the label and another is bound to a property that shows the actual data.

Similar to this, we have several TextBlock controls that display the data for different information types. Apart from the text controls, we have button controls to start and stop the sensor.

Data binding in WPF can be done very easily using the property notification API built into WPF applications. INotifyPropertyChanged is a powerful interface in the System.Component namespace and provides a standard way to notify binding to UI on a property change.

this.PropertyChanged.Invoke(this, new PropertyChangedEventArgs(propertyName));

Using INotifyPropertyChanged for data binding

Within our Kinect Info Box project, add a new class named MainWindowViewModel.cs and implement the INotifyPropertyChanged interface.

The very first thing we are going to do here is wrap the PropertyChanged event within a generic method so that we can call the same method for every property that needs to send the notifications.

As shown in the following code block, we have a method named OnNotifyPropertyChange, which accepts the propertyName variable as a parameter and passes it within PropertyChangedEventArgs:

public void OnNotifyPropertyChange(string propertyName)
{
    if (this.PropertyChanged != null)
    {
 this.PropertyChanged.Invoke(this, new PropertyChangedEventArgs (propertyName));
    }
}

The class also contains the list of properties with PropertyChanged in the setter block to see if a value is changing. Any changes in the values will automatically notify the UI. This is all very simple and useful. Implementation of any property that needs a notification looks like the following code snippet:

private string connectionIDValue;
public string ConnectionID
{
    get
    {
        return this.connectionIDValue;
    }
    set
    {
        if (this.connectionIDValue != value)
        {
            this.connectionIDValue = value;
 this.OnNotifyPropertyChange("ConnectionID");
        }
    }
}

We need all the properties to be defined in the same way for our MainWindowViewModel class. The following diagram is the class diagram for the MainWindowViewModel class:

private MainWindowViewModel viewModel;
public MainWindow()
{
    this.InitializeComponent();
    this.Loaded += this.MainWindow_Loaded;
 this.viewModel = new MainWindowViewModel();
 this.DataContext = this.viewModel;
}

private void SetKinectInfo()
{
    if (this.sensor != null)
    {
 this.viewModel.ConnectionID = this.sensor.DeviceConnectionId;
        // Set other property values
    }
}