Problem:                                                                                             

IE Developer Toolbar – JS Debugger Error “Unable to attach the process. Another debugger might be attached to the process” .

Steps :

1. Run an ASP.NET application from Visual Studio.

2. Once application launched, Press F12 in browser to launch Developer Toolbar.

3. Move to “Script” Tab and Click on “Start Debugging” . Put necessary breakpoints on the script function as required before click.

On click of “Start Debugging”, you will receive below error message. which says, already another debugger attached and you can not attach with current IE Process for debugging.

Solution :                                                                                    

Follow the below steps for resolve this issue.

1. Go back to Visual Studio and  Select “Detach All” from “Debug” menu.

2. Now click on “Start Debugging” from IE Developer Toolbar.  No error , and you can continue with debugging and other work.

Behind the scene :                                                                                 

Visual Studio automatically instantiate an Internet explorer process to launch the web sites. You can check the process level using “Process Explorer”.

Also, it attached the process  “iexplore.exe” automatically  during launch of site that helps us debug  JavaScript from visual studio itself. You can check  it from Solution explorer itself

Which mean, while your site is running in browser, “iexplore.exe” ( Process for Internet Explorer) is already attached .  One of the most simplest way to check this out is, navigate to  Debug > Windows> Processes .  This will list out all attached process with in visual studio . For any typical ASP.NET web application which is running from visual studio will have two process and iexplore is one of them.

That’s why when you are trying to attach the same process from IE Developer tool bar, it is throwing error “Unable to attach the process. Another debugger might be attached to the process” .

So now we know what was the causing the issue and let’s have a look what we did to resolve this. 

As a resolution,  we used “Detach All” from debug menu, which actually detach all the process which is attached with visual studio except local ASP.NET Development server process  ( WebDev.WebServer40.EXE ). 

Note : “Detach All” will detach all the attached process apart from ASP.NET Development server. Because detaching the development server is nothing but stopping your application. If you want to stop, either stop debugging or “Terminate” the local development sever process.

“Detach All” will remove iexplore.exe from the list of attached process. So, you can go ahead and start the debugging in IE Developer toolbar.

Detaching a Particular Process Instead “Detach All”                                        

If there are multiple processes attached and if you want to detach only “IE Process”, you can simply do it from process attach window, by selecting  “Detach Process” from the content menu of the “iexplore.exe”.  This will help you to retain on other process in attached state.

To know more about Processes Window, check out this post How to get list of attached processes in Visual Studio while debugging ?

Hope this helps !

Cheers !

Abhijit

1. How to enable Tier Interaction Profiling ( TIP ) in Visual Studio 2010 Profiler ?
2. Highlighting Execution Hot Path in Visual Studio 2010 Profiler Call Tree
3. Create Work Item in TFS for Specific Visual Studio 2010 Profiler Report
4. Setting Up Noise Reduction Option for Performance Reports in Visual Studio 2010 Profiler
5. How to change Default Performance Report Name in Visual Studio 2010 ?
6. Using Code Definition Window with Call Hierarchy in Visual Studio 2010
7. Navigate Code Using Code Definition Window in Visual Studio
8. Data Schema Comparison in Visual Studio 2010
9. Sort Generic List Using Lambda Expression For Dynamic Type And Dynamic Property
10. How to Pass Command Line Arguments using Visual Studio ?
11. Specifying Assembly Information in Visual Studio
12. Install a shared Assembly to the GAC as post build event from Visual Studio
13. Programmatically Get Assembly Version
14. Maps Keys to a Collection of Values using Lookup Collection
15. Conditional Binding Expression with ASP.NET GridView
16. How to change selected date background color of current week in ASP.NET Calendar ?
17. How to Change Background Color of Current Week in ASP.NET Calendar ?
18. How to enable code coverage in Visual Studio 2010 ?
19. Setting up Policies for Extensible Parts in MEF
20. Use of ImportConstructor to inject Constructor code in MEF
21. Writing Metadata in Contracts of MEF
22. Working with CompositionBatch in MEF
23. Allow Recomposition in MEF
24. Getting Lazy with MEF
25. PartNotDiscoverable attribute in MEF

To get regular updates visit http://dailydotnettips.com and follow @dailydotnettips at Twitter

Once both devices configured and setup properly,  you can run the below code snippet to check if Kinect SDK detects both of  the  devices.

Once you have the correct device count you can start with application development. During this exercise we will be applying all the learning that we have gained over the past few articles.

Let’s start with the a New “WPF” Project and named it as “MultipleKinectDemo”

Navigate to solution explorer, Right Click on the Project and Select “Add Reference” and add “Microsoft.Research.Kinect.dll” as reference assembly.

Add a new class named “KinectDevice”  which will be  a container entity for multiple Kinect devices.   Below is the code snippet for the KinectDevice.cs.

using Microsoft.Research.Kinect.Nui;
/// <summary>
/// Kinect Device
/// </summary>
public sealed class KinectDevice
{
    /// <summary>
    /// Gets or sets the name of the device.
    /// </summary>
    /// <value>The name of the device.</value>
    public string DeviceName { get; set; }

    /// <summary>
    /// Gets or sets the kinect runtime.
    /// </summary>
    /// <value>The kinect runtime.</value>
    public Runtime KinectRuntime { get; set; }
}

In the above class “KinectRuntime” is type of  Kinect Runtime and  We will be creating a List<KinectDevice> to contain the multiple object of devices.

Capturing video, Depth images are same as we did earlier for a single kinect, but the new steps involves with initializing of multiple Kinect devices.   The Kinect .NET SDK does provide support for multiple Kinect devices.   Runtime class has a overloaded constructed where it take index as argument.

You can create a new Runtime object and pass the index of sensors  as   runtimeNui = new Runtime(index).

In our application we will create a List<KinectDevice> and store the  each runtime object  .

Before that, create a basic US as shown in below,

Very straight forward UI, you can check out the XAML markup which in given in then end.

Let’s do it now Step by Step

Detect Kinect Devices 

First of all we need to detect the devices. Kinect SDK APIs provides a class “Device” which represents a system’s Kinect sensors. It’s has a property “Count” which holds the number of Kinect been detected.  Write the blow code snippet in the Detect Button click event.

 /// <summary>
        /// Handles the Click event of the buttonDetect control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
        private void buttonDetect_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                Device device = new Device();
                this.DeviceCount = device.Count;
                this.buttonDetect.Content = string.Format("Kinect Device Detected {0}", this.DeviceCount.ToString());
            }
            catch (Exception exp)
            {
                MessageBox.Show(string.Format("Error Occured in Device Detection : ", exp.Message));
            }
        }

this.DeviceCount is a private properties which defined locally to the current class.

        /// <summary>
        /// Gets or sets the device count.
        /// </summary>
        /// <value>The device count.</value>
        private int DeviceCount { get; set; }

After successfully detection of the devices, we changed the content of the Button with number of detected device.

Multiple Kinect Runtime

As discussed earlier, Kinect .SDK support detection of multiple SDK and Runtime class has a overloaded constructor that takes index as arguments.  Below code snippets shows how we can initialize multiple Kinect Runtime

 /// <summary>
        /// Handles the Click event of the buttonInitializeRuntime control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
        private void buttonInitializeRuntime_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                for (int i = 0; i < this.DeviceCount; i++)
                {
                    kinectDevices.Add(new KinectDevice
                                        {
                                            KinectRuntime = new Runtime(i),
                                            DeviceName = string.Format("{0} {1}",
                                            DeviceName, i.ToString())
                                        });
                }

                this.buttonKinectOne.IsEnabled = true;
                this.buttonKinectTwo.IsEnabled = true;
            }
            catch (Exception exp)
            {
                MessageBox.Show(string.Format("Runtime Initialization Failed : ", exp.Message));
            }
        }

kinectDevices is a List of KinectDevice which I have discussed earlier.

        /// <summary>
        /// Kinect Device Place Holder
        /// </summary>
        List<KinectDevice> kinectDevices = new List<KinectDevice>();

Taking Control over Individual Kinect  

Once we have the runtime initialized, we can easily take control over the individual Kinect. kinectDevices[0] and kinectDevices[1] are the runtime container for individual Kinect. Below code snippets show how we can detect the first Kinect devices.

  /// <summary>
        /// Handles the Click event of the buttonKinectOne control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
        private void buttonKinectOne_Click(object sender, RoutedEventArgs e)
        {
            KinectDevice deviceOne = kinectDevices[0];
            Runtime deviceRuntimeOne = deviceOne.KinectRuntime;
            deviceRuntimeOne.Initialize(RuntimeOptions.UseColor);
            deviceRuntimeOne.NuiCamera.ElevationAngle = 0;
            deviceName1.Content = deviceOne.DeviceName;
            deviceRuntimeOne.VideoFrameReady += new EventHandler<ImageFrameReadyEventArgs>(deviceRuntimeOne_VideoFrameReady);
            deviceRuntimeOne.VideoStream.Open(ImageStreamType.Video, 2, ImageResolution.Resolution640x480, ImageType.Color);
        }

As we have the specific Kinect runtime, we can easily take care of VideoFrameReady event and  VideoStream.Open() method.

 /// <summary>
        /// Handles the VideoFrameReady event of the deviceRuntimeOnce control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="Microsoft.Research.Kinect.Nui.ImageFrameReadyEventArgs"/> instance containing the event data.</param>
        void deviceRuntimeOne_VideoFrameReady(object sender, ImageFrameReadyEventArgs e)
        {
            image1.Source = e.ImageFrame.ToBitmapSource();
            PlanarImage imageData = e.ImageFrame.Image;
            camera1Small.Source = BitmapSource.Create(imageData.Width, imageData.Height, 96, 96, PixelFormats.Cmyk32, null, imageData.Bits, imageData.Width * imageData.BytesPerPixel);
        }

Similar we can write the code for kinectDevices[1]

Well, this is the base, rest things are very similar to work with single Kinect device.

Here is the complete code snippet of the application

/// Developing Application using Multiple Kinect
/// Author : Abhijit Jana
/// Date : 17 - 09 2011
/// ---------------------------------------------------------------------------

namespace MultipleKinectDemo
{
    using System;
    using System.Collections.Generic;
    using System.Windows;
    using Coding4Fun.Kinect.Wpf;
    using Microsoft.Research.Kinect.Nui;
    using System.Windows.Media;
    using System.Windows.Media.Imaging;

    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        /// <summary>
        /// Gets or sets the device count.
        /// </summary>
        /// <value>The device count.</value>
        private int DeviceCount { get; set; }

        /// <summary>
        /// Kinect Device Place Holder
        /// </summary>
        List<KinectDevice> kinectDevices = new List<KinectDevice>();

        private const string DeviceName = "Kinect Sensors Device";

        /// <summary>
        /// Initializes a new instance of the <see cref="MainWindow"/> class.
        /// </summary>
        public MainWindow()
        {
            InitializeComponent();
            Loaded += new RoutedEventHandler(MainWindow_Loaded);
            Unloaded += new RoutedEventHandler(MainWindow_Unloaded);
        }

        /// <summary>
        /// Handles the Unloaded event of the MainWindow control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
        void MainWindow_Unloaded(object sender, RoutedEventArgs e)
        {
            foreach (KinectDevice device in kinectDevices)
            {
                device.KinectRuntime.Uninitialize();
            }
        }

        /// <summary>
        /// Handles the Loaded event of the MainWindow control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
        void MainWindow_Loaded(object sender, RoutedEventArgs e)
        {
            this.buttonKinectOne.IsEnabled = false;
            this.buttonKinectTwo.IsEnabled = false;
        }

        /// <summary>
        /// Handles the Click event of the buttonDetect control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
        private void buttonDetect_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                Device device = new Device();
                this.DeviceCount = device.Count;
                this.buttonDetect.Content = string.Format("Kinect Device Detected {0}", this.DeviceCount.ToString());
            }
            catch (Exception exp)
            {
                MessageBox.Show(string.Format("Error Occured in Device Detection : ", exp.Message));
            }
        }

        /// <summary>
        /// Handles the Click event of the buttonInitializeRuntime control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
        private void buttonInitializeRuntime_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                for (int i = 0; i < this.DeviceCount; i++)
                {
                    kinectDevices.Add(new KinectDevice
                                        {
                                            KinectRuntime = new Runtime(i),
                                            DeviceName = string.Format("{0} {1}",
                                            DeviceName, i.ToString())
                                        });
                }

                this.buttonKinectOne.IsEnabled = true;
                this.buttonKinectTwo.IsEnabled = true;
            }
            catch (Exception exp)
            {
                MessageBox.Show(string.Format("Runtime Initialization Failed : ", exp.Message));
            }
        }

        /// <summary>
        /// Handles the Click event of the buttonKinectOne control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
        private void buttonKinectOne_Click(object sender, RoutedEventArgs e)
        {
            KinectDevice deviceOne = kinectDevices[0];
            Runtime deviceRuntimeOne = deviceOne.KinectRuntime;
            deviceRuntimeOne.Initialize(RuntimeOptions.UseColor);
            deviceRuntimeOne.NuiCamera.ElevationAngle = 0;
            deviceName1.Content = deviceOne.DeviceName;
            deviceRuntimeOne.VideoFrameReady += new EventHandler<ImageFrameReadyEventArgs>(deviceRuntimeOne_VideoFrameReady);
            deviceRuntimeOne.VideoStream.Open(ImageStreamType.Video, 2, ImageResolution.Resolution640x480, ImageType.Color);
        }

        /// <summary>
        /// Handles the VideoFrameReady event of the deviceRuntimeOnce control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="Microsoft.Research.Kinect.Nui.ImageFrameReadyEventArgs"/> instance containing the event data.</param>
        void deviceRuntimeOne_VideoFrameReady(object sender, ImageFrameReadyEventArgs e)
        {
            image1.Source = e.ImageFrame.ToBitmapSource();
            PlanarImage imageData = e.ImageFrame.Image;
            camera1Small.Source = BitmapSource.Create(imageData.Width, imageData.Height, 96, 96, PixelFormats.Cmyk32, null, imageData.Bits, imageData.Width * imageData.BytesPerPixel);
        }

        /// <summary>
        /// Handles the Click event of the buttonKinectTwo control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
        private void buttonKinectTwo_Click(object sender, RoutedEventArgs e)
        {
            KinectDevice deviceTwo = kinectDevices[1];
            Runtime deviceRuntimeTwo = deviceTwo.KinectRuntime;
            deviceRuntimeTwo.Initialize(RuntimeOptions.UseColor);
            deviceRuntimeTwo.NuiCamera.ElevationAngle = 0;
            deviceName2.Content = deviceTwo.DeviceName;
            deviceRuntimeTwo.VideoFrameReady += new EventHandler<ImageFrameReadyEventArgs>(deviceRuntimeTwo_VideoFrameReady);
            deviceRuntimeTwo.VideoStream.Open(ImageStreamType.Video, 2, ImageResolution.Resolution640x480, ImageType.Color);
        }

        /// <summary>
        /// Handles the VideoFrameReady event of the deviceRuntimeTwo control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="Microsoft.Research.Kinect.Nui.ImageFrameReadyEventArgs"/> instance containing the event data.</param>
        void deviceRuntimeTwo_VideoFrameReady(object sender, ImageFrameReadyEventArgs e)
        {
            image2.Source = e.ImageFrame.ToBitmapSource();
            PlanarImage imageData = e.ImageFrame.Image;
            camera2Small.Source = BitmapSource.Create(imageData.Width, imageData.Height, 96, 96, PixelFormats.Cmyk32, null, imageData.Bits, imageData.Width * imageData.BytesPerPixel);
        }

        /// <summary>
        /// Handles the Click event of the camera1Up control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
        private void camera1Up_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                kinectDevices[0].KinectRuntime.NuiCamera.ElevationAngle = kinectDevices[0].KinectRuntime.NuiCamera.ElevationAngle + 5;
            }
            catch (ArgumentOutOfRangeException aore)
            {

                MessageBox.Show("Elevation angle must be between Elevation Minimum/Maximum");
            }

            catch (Exception)
            {

            }

        }

        /// <summary>
        /// Handles the Click event of the camera1Down control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
        private void camera1Down_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                kinectDevices[0].KinectRuntime.NuiCamera.ElevationAngle = kinectDevices[0].KinectRuntime.NuiCamera.ElevationAngle - 5;
            }
            catch (ArgumentOutOfRangeException argumentExcpetion)
            {
                MessageBox.Show("Elevation angle must be between Elevation Minimum/Maximum");
            }
        }

        /// <summary>
        /// Handles the Click event of the camera2Up control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
        private void camera2Up_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                kinectDevices[1].KinectRuntime.NuiCamera.ElevationAngle = kinectDevices[1].KinectRuntime.NuiCamera.ElevationAngle + 5;
            }
            catch (ArgumentOutOfRangeException argumentExcpetion)
            {

                MessageBox.Show("Elevation angle must be between Elevation Minimum/Maximum");
            }
        }

        /// <summary>
        /// Handles the Click event of the camera2Down control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
        private void camera2Down_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                kinectDevices[1].KinectRuntime.NuiCamera.ElevationAngle = kinectDevices[1].KinectRuntime.NuiCamera.ElevationAngle - 5;
            }
            catch (ArgumentOutOfRangeException aore)
            {
                MessageBox.Show("Elevation angle must be between Elevation Minimum/Maximum");
            }
        }
    }
}

XAML Markup. just drag and drop control

<Grid>
        <Border BorderBrush="Silver" BorderThickness="5" Height="257" HorizontalAlignment="Left"
                Margin="32,207,0,0" Name="border1" VerticalAlignment="Top" Width="269"></Border>
        <Border BorderBrush="Silver" BorderThickness="5" Height="257" Name="border2" Width="269" Margin="488,206,46,90">
            <Image Height="246" Name="image2" Stretch="Fill" Width="259" />
        </Border>
        <Button Content="Kinect 1" Height="42" HorizontalAlignment="Left" Margin="35,480,0,0" Name="buttonKinectOne" VerticalAlignment="Top" Width="266" Click="buttonKinectOne_Click" />
        <Button Content="Kinect 2" Height="42" HorizontalAlignment="Right" Margin="0,480,51,0" Name="buttonKinectTwo" VerticalAlignment="Top" Width="259" Click="buttonKinectTwo_Click" />
        <Button Content="Detect Kinects" Height="40" HorizontalAlignment="Left" Margin="243,12,0,0" Name="buttonDetect" VerticalAlignment="Top" Width="280" Click="buttonDetect_Click" />
        <Label Content="Camera Device Name" Height="26" HorizontalAlignment="Left" Margin="32,180,0,0" Name="deviceName1" VerticalAlignment="Top" Width="271" />
        <Label Content="Camera Device Name" Height="26" HorizontalAlignment="Left" Margin="486,180,0,0" Name="deviceName2" VerticalAlignment="Top" Width="271" />
        <Image Height="249" Name="image1" Stretch="Fill" Margin="35,211,502,93" />
        <Button Content="Initialize Runtime" Height="38" HorizontalAlignment="Left" Margin="243,67,0,0" Name="buttonInitializeRuntime" VerticalAlignment="Top" Width="280" Click="buttonInitializeRuntime_Click" />
        <Button Content="UP" FontWeight="ExtraBold" Height="43" HorizontalAlignment="Left" Margin="307,356,0,0" Name="camera1Up" VerticalAlignment="Top" Width="41" Click="camera1Up_Click" />
        <Button Content="Down" FontWeight="ExtraBold" Height="43" HorizontalAlignment="Left" Margin="307,413,0,0" Name="camera1Down" VerticalAlignment="Top" Width="41" Click="camera1Down_Click" />
        <Image Height="109" HorizontalAlignment="Left" Margin="254,228,0,0" Name="camera1Small" Stretch="Fill" VerticalAlignment="Top" Width="127" />
        <Border BorderBrush="#FFB10E00" BorderThickness="1" Height="121" HorizontalAlignment="Left" Margin="248,222,0,0" Name="border3" VerticalAlignment="Top" Width="140"></Border>
        <Button Content="UP" FontWeight="ExtraBold" Height="43" HorizontalAlignment="Left" Margin="441,356,0,0" Name="camera2Up" VerticalAlignment="Top" Width="41" Click="camera2Up_Click" />
        <Button Content="Down" FontWeight="ExtraBold" Height="43" HorizontalAlignment="Left" Margin="441,413,0,0" Name="camera2Down" VerticalAlignment="Top" Width="41" Click="camera2Down_Click" />
        <Border BorderBrush="#FFB10E00" BorderThickness="1" Height="121" Name="border4" Width="140" Margin="402,222,261,210">
            <Image Height="118" Name="camera2Small" Stretch="Fill" Width="133" />
        </Border>
    </Grid>

Here is the output of the above application.

Download Complete Project

Hope this helps !
Cheers !
Aj

The Kinect SDK does provide support for Multiple Kinect devices and we can plug multiple devices in a same system.  Let’s first check the configuration related with H/W. What will happen if we plugged in multiple Kinect.

Navigate to Control Panel > Device Manager and Expand “Microsoft Kinect” .

You will find multiple Kinect devices has been detected by your system. But, Check out the “Warning Symbol” with one of Kinect Camera Devices

Right Click on that item and Select Properties, below dialog screen will appear. Check out the Device Status section it’s says “This Device Cannot start. (Code 10) .

I was just wondering why it is not working ? Is there something wrong with second Kinect Device ?  The result was same after changing the USB ports for Kinect devices with in the different ports that were available with my laptop.

I started investigation and found some answer over here. It’s says, There is currently a limitation where Kinect devices might not work reliably when they are connected to the same USB host controller as other USB devices, such as webcams or other Kinect devices.

What I did next is, Changed the device manager view to “Devices by Connection”

What I found is , Both of the Kinect are being controlled by Same USB Controller. So, it was looks like I don’t have any chance to work multiple Kinect as I checked with all the USB ports.

Well, Jebarson gave me an idea to plugged into the USB ports which were available with Laptop docking station. I just did that. Well, it worked. Check out the below snaps, both the Kinect Sensors detected properly.

So, we are done with H/W Configuration stuff . What about accessing them using Application ?

Kinect SDK APIs provides a class “Device” which represents a system’s Kinect sensors. It’s has a property “Count” which will show the number of Kinect been detected.  So, I wrote following line of code, and check out the result.

That’s all from here. In next Post we will check how to develop application Multiple Kinect . That will be more interesting.

Other Posts from this series :

Development With Kinect .NET SDK (Part I) – Installation and Development Environment Setup

Development With Kinect .NET SDK (Part II) – Using NUI APIs with Camera

Development With Kinect .NET SDK (Part III) – Adjusting the Kinect Camera Angle

Hope this helps !

Cheers !!

Abhijit

Step 1. Create a New WPF Project in Visual Studio 2010 named it as “AdjustingKinectCameraDemo”

Step 2. Add “Microsoft.Research.Kinect.dll” as Reference Assembly.

Step 3. Open the code view of your application and add “Microsoft.Research.Kinect.Nui” as Namespaces.

Step 4. The next thing we are going to do is, designing a small UI with one Image Control, TextBox and a Button control.

You can use below XAML Markup for the above design

 <Grid>
        <Image Height="203" HorizontalAlignment="Left" Margin="120,23,0,0"
               Name="imageControl" Stretch="Fill" VerticalAlignment="Top" Width="268" />
        <TextBox Height="34" HorizontalAlignment="Left"
                 Margin="158,240,0,0" Name="textAngel"
                 VerticalAlignment="Top" Width="119" />
        <Button Content="Ok" Height="36" HorizontalAlignment="Left"
                Margin="287,240,0,0" Name="buttonAngel"
                VerticalAlignment="Top" Width="89" Click="buttonAngle_Click" />
    </Grid>

Step 5. The next step is to initialize the Kinect Runtime and display the video into image control. We did this exercise in our last post.  So, here I am not explaining how to do that, Just use below code snippet for the same.

       /// <summary>
        /// Define the Kinect Sensor Runtime
        /// </summary>
        Runtime kinectRuntime = new Runtime();

        /// <summary>
        /// Initializes a new instance of the <see cref="MainWindow"/> class.
        /// </summary>
        public MainWindow()
        {
            InitializeComponent();
            Loaded += new RoutedEventHandler(MainWindow_Loaded);
            Unloaded += new RoutedEventHandler(MainWindow_Unloaded);
        }

        /// <summary>
        /// Handles the Unloaded event of the MainWindow control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
        void MainWindow_Unloaded(object sender, RoutedEventArgs e)
        {
            // Uninitialize the Device when Unload
            this.kinectRuntime.Uninitialize();
        }

        /// <summary>
        /// Handles the Loaded event of the MainWindow control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
        void MainWindow_Loaded(object sender, RoutedEventArgs e)
        {
            // Initialize the Device when Load
            this.kinectRuntime.Initialize(RuntimeOptions.UseColor);
            this.kinectRuntime.VideoFrameReady += new EventHandler<ImageFrameReadyEventArgs>(kinectRuntime_VideoFrameReady);
            this.kinectRuntime.VideoStream.Open(ImageStreamType.Video, 2, ImageResolution.Resolution640x480, ImageType.Color);
        }

        /// <summary>
        /// Handles the VideoFrameReady event of the kinectRuntime control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="Microsoft.Research.Kinect.Nui.ImageFrameReadyEventArgs"/> instance containing the event data.</param>
        void kinectRuntime_VideoFrameReady(object sender, ImageFrameReadyEventArgs e)
        {
            PlanarImage planarImage = e.ImageFrame.Image;
            imageControl.Source = BitmapSource.Create(planarImage.Width, planarImage.Height, 96, 96, PixelFormats.Bgr32, null, planarImage.Bits, planarImage.Width * planarImage.BytesPerPixel);
        }

Step 6 : Change the camera angle on button click as show in below code snippet.

  /// <summary>
        /// Handles the Click event of the buttonAngle control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
        private void buttonAngle_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                // Set the ElevationAngle of current runtime camera
                this.kinectRuntime.NuiCamera.ElevationAngle = Convert.ToInt32(this.textAngel.Text);
            }
            catch (ArgumentOutOfRangeException exp)
            {
                MessageBox.Show(exp.Message);
            }
        }

If the value of Elevation Angel > 27 or < -27  degree application will trow a “ArgumentOutOfRangException” .

That’s all, just run the application and give the textbox value in between +27 to  -27, you will see the Kinect motorized tilt is changing with the camera angel. Below is the screen shots with Angel 0, +27 and – 27 degrees where as  the position of Kinect device was same.

Check out the quick Video demo as well.

Note, this features is not for frequent uses. Generally this need to setup and track skeleton during the start up of your Application.

Read Kinect SDK Documentation for more information.

Download Complete Project

Till now whatever we have learned we learned about a single Kinect Device. In my next two post I will discussion about configuring multiple Kinect Devices and then will develop a application using Multiple devices. Then we will bake with Skeleton Tracking and Audio fundamentals.  So lot’s of interesting stuff on the way !!!

Hope this helps !

Cheers !!

AJ

As we are going to explore the NUI APIs, first of all I will try to explain about fundamentals of Kinect SDK Library and type of APIs, then we will look inside NUI APIs and in the end we will be developing some application as shown in below.

Yeah. Super cool and lots of learning from this article !!

NUI APIs are the set of APIs that retrieves data from Kinect Sensors, camera and control the devices. This enables you to access images and stream data from Kinect Sensors.  So, what it does? For any kind of application your application access the NUI APIs, which interacts with Kinect Sensors and transfer back Image Stream, Depth Stream data to applications and this APIs also allow user to take control of Kinect Motor.

Why this is called as Natural User Interface (NUI ) ? , because this APIs help developer to use the Kinect for Natural Inputs like skeleton tracking, sensing, depth measuring etc.   As said, NUI APIs interacts with Camera , Sensors and Motors where as you  need a separate set of APIs to take control over Audio Mic Array ( We are not covering Audio array part in this article) . Below picture illustrate overall API Classification for Kinect SDK.

To start with any Kinect application, you have to Add Microsoft.Research.Kinect.dll as reference to interact with Kinect and first of all we need to  define a Runtime of Kinect Sensors.

This will create an instance of Kinect which represent the current device. ( Well, you can interact with multiple Kinect , will talk about this later ) .  Below diagram representing the overall APIs available for  Kinect SDK NUI . Let’s focus on the methods inside Runtime Class. This contain Initialize() and Uninitialize() method along with other methods. This two methods user for initializing and Uninitializing the Kinect Runtime.

In my previous post I talked about initializing and uninitializing of Kinect runtime.  Initialize() method Initializes the NUI subsystems that the application requires.  we have initialized the Kinect Runtime with RuntimeOptions as shown in below snippet.

RuntimeOptions specifies the runtime options for a Kinect sensor.  Kinect process data using Multi-stage channel. So, specifying runtime tell the what are the channel need to start.

RuntimeOption is a public Enumeration inside the NUI library.

UseColor streams the color image from the Kinect and this is used for color Video. UseDepth option stream the depth image data and UseSkeleatal provides the skeleton positions.

When you are done with all operation, call Runtime.Uninitialize() to close the instance.

Well, we learned lot about NUI API. Let’s used some of these API

Demo : NUI API’s Video and Depth Image

Start a new Visual Studio Instance and Create a New WPF Project Template with Name “KinectCameraNUIDemo”.

From Solution Explorer, right click on the project and Add “Microsoft.Research.Kinect.dll” as reference assembly

you already knows about the initializing the Kinect devices, so I am not discussing on that. Below code snippets shows the basic code blocks which instantiate a Kinect Runtime for the create WPF Application.

 /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        /// <summary>
        /// Runtime Instance for Device
        /// </summary>
        Runtime nuiRuntime = new Runtime();

        /// <summary>
        /// Initializes a new instance of the <see cref="MainWindow"/> class.
        /// </summary>
        public MainWindow()
        {
            InitializeComponent();
            Loaded += new RoutedEventHandler(MainWindow_Loaded);
            Unloaded += new RoutedEventHandler(MainWindow_Unloaded);
        }

        /// <summary>
        /// Handles the Unloaded event of the MainWindow control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
        void MainWindow_Unloaded(object sender, RoutedEventArgs e)
        {
            // Uninitialize the Kinect
            nuiRuntime.Uninitialize();
        }

        /// <summary>
        /// Handles the Loaded event of the MainWindow control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
        void MainWindow_Loaded(object sender, RoutedEventArgs e)
        {
           // Initialize the Runtime with Color Channel
            nuiRuntime.Initialize(RuntimeOptions.UseColor);
        }
    }

We are going to display some video capture from Kinect. So, lets first create the UI. The UI is very simple, put one Image and one button control.

Below is the XAML markup for the above design.

 <Grid Height="365">
        <Image Height="277" HorizontalAlignment="Left"
               Margin="64,12,0,0"
               Name="videoControl"
               Stretch="Fill"
               VerticalAlignment="Top" Width="385" />
        <Button Content="Capture"
                Height="41" HorizontalAlignment="Left"
                Margin="191,295,0,0" Name="buttonCapture"
                VerticalAlignment="Top" Width="143" />
    </Grid>

You have already initialized the Kinect runtime with UseColor RuntimeOptions. Which means, Kinect already initialized a channel for the color image streaming.  So in the next step you need to write an event handler for video frame. This Occurs when a video frame is ready. Code snippet for the VideoFrameReady event handler look like this :

Once you have done with signing the video frame, in next step you have to Open a video Stream channel for the image stream.

ImageStreamType gets the image stream type. It can be Video or Depth depends the type of event handler we have attached with it. Along with the ImageStreamType you have specify the pool size , resolution and ImageType which is also an enumeration that specifies an image type .

Let’s have handle the event for VideoFrameReady. Kinect  Video returns PlanarImage  and we just need to create new Bitmap source and display on the Image control.

        /// <summary>
        /// Handles the VideoFrameReady event of the nuiRuntime control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="Microsoft.Research.Kinect.Nui.ImageFrameReadyEventArgs"/> instance containing the event data.</param>
        void nuiRuntime_VideoFrameReady(object sender, ImageFrameReadyEventArgs e)
        {
            PlanarImage planarImage = e.ImageFrame.Image;
            videoControl.Source = BitmapSource.Create(planarImage.Width, planarImage.Height, 96, 96,
                PixelFormats.Bgr32, null, planarImage.Bits, planarImage.Width * planarImage.BytesPerPixel);

      }

That’s all, let run the application. and Click on the “Capture Button”, you will find output like below,

of course this should be a video display, not still image !!!

Very easy to capture Video. Want to make more easy , yes you can do it using Coding for Fun Kinect Toolkit . This Toolkit contains some useful extension methods for both WinForm and WPF version which will make things much easier.

As for example, using this Coding for Fun Toolkit, you need to write below code block for VideoStream event handler.

  /// <summary>
        /// Handles the VideoFrameReady event of the nuiRuntime control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="Microsoft.Research.Kinect.Nui.ImageFrameReadyEventArgs"/> instance containing the event data.</param>
        void nuiRuntime_VideoFrameReady(object sender, ImageFrameReadyEventArgs e)
        {
            //PlanarImage planarImage = e.ImageFrame.Image;
            //videoControl.Source = BitmapSource.Create(planarImage.Width, planarImage.Height, 96, 96,
            //    PixelFormats.Bgr32, null, planarImage.Bits, planarImage.Width * planarImage.BytesPerPixel);

            videoControl.Source = e.ImageFrame.ToBitmapSource();
      }

but before using Coding for Fun APIs, you have add the “Coding4Fun.Kinect.Wpf.dll” ( As this a WPF Application ) as reference and put using Coding4Fun.Kinect.Wpf; as namespaces.

Let’s make this demo more interesting, while we are creating a bitmap using BitmapSource.Create() , we are passing the PixelFormats as one of the argument. Let’s change it do something different (Cmyk32) and bind the image to a different Image control.

/// <summary>
        /// Handles the VideoFrameReady event of the nuiRuntime control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="Microsoft.Research.Kinect.Nui.ImageFrameReadyEventArgs"/> instance containing the event data.</param>
        void nuiRuntime_VideoFrameReady(object sender, ImageFrameReadyEventArgs e)
        {
            PlanarImage planarImage = e.ImageFrame.Image;
            videoControl.Source = BitmapSource.Create(planarImage.Width, planarImage.Height, 96, 96,
                PixelFormats.Bgr32, null, planarImage.Bits, planarImage.Width * planarImage.BytesPerPixel);

            videoSource2.Source = BitmapSource.Create(planarImage.Width, planarImage.Height, 96, 96,
              PixelFormats.Cmyk32, null, planarImage.Bits, planarImage.Width * planarImage.BytesPerPixel);
         }

Below is the resulting output :

Till now we covered only about the Video images, let’s have a look what happened for Depth Image.  Handling depth stream image is pretty similar to handling the Video steam, the only change required is the type of images and streams.

The first thing you need to change is initialization of runtime. This time you have to use UseDepth as well.

Once you are done with initialization, you need to raise an event handler for Depth Stream and need to open a new channel for Depth image where you have to specify the ImageStreamType as Depth and ImageType as Depth.

That’s all you really do not need to worry about other stuff. You can put multiple image control and bind different types of images to display it. Yes, its all about fun !!

Here is the complete code snippet :

namespace KinectCameraNUIDemo
{
    using System;
    using System.Windows;
    using System.Windows.Media;
    using System.Windows.Media.Imaging;
    using Coding4Fun.Kinect.Wpf;
    using Microsoft.Research.Kinect.Nui;

    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        /// <summary>
        /// Runtime Instance for Device
        /// </summary>
        Runtime nuiRuntime = new Runtime(0);

        /// <summary>
        /// Initializes a new instance of the <see cref="MainWindow"/> class.
        /// </summary>
        public MainWindow()
        {

            InitializeComponent();
            Loaded += new RoutedEventHandler(MainWindow_Loaded);
            Unloaded += new RoutedEventHandler(MainWindow_Unloaded);
        }

        /// <summary>
        /// Handles the Unloaded event of the MainWindow control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
        void MainWindow_Unloaded(object sender, RoutedEventArgs e)
        {
            // Uninitialize the Kinect
            nuiRuntime.Uninitialize();
        }

        /// <summary>
        /// Handles the Loaded event of the MainWindow control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
        void MainWindow_Loaded(object sender, RoutedEventArgs e)
        {
            // Initialize the Runtime with Color Channel
            nuiRuntime.Initialize(RuntimeOptions.UseColor | RuntimeOptions.UseDepth);

        }

        /// <summary>
        /// Handles the Click event of the buttonCapture control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
        private void buttonCapture_Click(object sender, RoutedEventArgs e)
        {

            // Signing the Event for Image frame ready
            nuiRuntime.VideoFrameReady += new EventHandler<ImageFrameReadyEventArgs>(nuiRuntime_VideoFrameReady);
            nuiRuntime.DepthFrameReady += new EventHandler<ImageFrameReadyEventArgs>(nuiRuntime_DepthFrameReady);
            nuiRuntime.VideoStream.Open(ImageStreamType.Video, 2, ImageResolution.Resolution640x480, ImageType.Color);
            nuiRuntime.DepthStream.Open(ImageStreamType.Depth, 2, ImageResolution.Resolution320x240, ImageType.Depth);
        }

        void nuiRuntime_DepthFrameReady(object sender, ImageFrameReadyEventArgs e)
        {
            depthSourceControl.Source = e.ImageFrame.ToBitmapSource();

        }

        /// <summary>
        /// Handles the VideoFrameReady event of the nuiRuntime control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="Microsoft.Research.Kinect.Nui.ImageFrameReadyEventArgs"/> instance containing the event data.</param>
        void nuiRuntime_VideoFrameReady(object sender, ImageFrameReadyEventArgs e)
        {
            PlanarImage planarImage = e.ImageFrame.Image;
            videoControl.Source = BitmapSource.Create(planarImage.Width, planarImage.Height, 96, 96,
                PixelFormats.Bgr32, null, planarImage.Bits, planarImage.Width * planarImage.BytesPerPixel);

            videoSource2.Source = BitmapSource.Create(planarImage.Width, planarImage.Height, 96, 96,
              PixelFormats.Cmyk32, null, planarImage.Bits, planarImage.Width * planarImage.BytesPerPixel);

            videoSource3.Source = BitmapSource.Create(planarImage.Width, planarImage.Height, 96, 96,
              PixelFormats.Bgr24, null, planarImage.Bits, planarImage.Width * planarImage.BytesPerPixel);
        }
    }
}

Below is the XAML Markup Snippet, I just drag and drop few control .

  <Grid Height="451" Width="607">
         <Image Height="343" HorizontalAlignment="Left"
               Margin="12,12,0,0"
               Name="videoControl"
               Stretch="Fill"
               VerticalAlignment="Top" Width="385" />
        <Button Content="Capture"
                Height="41" HorizontalAlignment="Left"
                Margin="299,376,0,0" Name="buttonCapture"
                VerticalAlignment="Top" Width="143" Click="buttonCapture_Click" />
        <Image Height="150" HorizontalAlignment="Left" Margin="360,23,0,0"
               Name="videoSource2" Stretch="Fill" VerticalAlignment="Top" Width="200" />
        <Image Height="150" HorizontalAlignment="Left" Margin="360,183,0,0"
               Name="depthSourceControl" Stretch="Fill" VerticalAlignment="Top" Width="200" />
        <Image Height="113" HorizontalAlignment="Left" Margin="481,129,0,0"
               Name="videoSource3" Stretch="Fill" VerticalAlignment="Top" Width="114" />
    </Grid>

References :

Coding for Fun
Kinect Documentation

Download Complete Project

In this post we have learned about NUI API’s and learned how we can use those APIs to interact with Kinect Camera and sensors. In the next post I will talk about something more on camera and then we will start with skeleton tracking followed by Audio.

Read Out First Part over here Development With Kinect .NET SDK (Part I) – Installation and Development Environment Setup
Hope this helps !

Cheers !!

AJ

So what are the thing we are going to learn today ? Well, we will learn about the system requirements and the installation of the Kinect device, which will ensure that our device setup properly and we are good to start with development.

Get Ready with Your Development Environment

The current version of Kinect for Windows SDK beta 1  needs below requirements to start

Hardware

• Kinect for Xbox 360 sensor
• Computer with a dual-core, 2.66-GHz or faster processor
• Windows 7–compatible graphics card that supports DirectX® 9.0c capabilities
• 2-GB RAM (4-GB RAM recommended)

Software

• Windows 7 (x86 or x64)
• Visual Studio 2010 Express (or other 2010 edition)
• Microsoft .NET Framework 4.0

Refer ^ for more information

Download and Install Kinect for Windows SDK beta

Download the SDK Beta, Once you have the development environment setup ready. Please make sure you are downloading the SDK Version based on 64bit or 32bit Operating System. Once done with download, install it. You really do not need to plugin your Kinect devices during the installation of SDK.

 Know your Kinect Device

Before checking out Driver installation, let’s have a quick look into the basic H/W elements of Kinect. This contains 3d Depth Sensors, RGB Camera which is used for Video Capturing , Array of MIC and TILT.

Kinect SDK provides some API to interact with motorized tilt to enables the camera up or down 27 degrees  . This API is the part of Kinect Camera.

I will be talking details about each and everything in my upcoming post while exploring the API’s for each every section.

Checkout your Installation of Device Driver

Plug in your Kinect USB cable with Computer. Once Windows detects the devices, you will get the LED Indicator blinking ( Yeah, this one is mine) .

Wait for Windows to recognize the sponsor’s.  You can check it out from Control Panel > Device Manager for the installed device driver. By default with only USB connection, Windows will detect only the device, as shown in below picture.

But, Camera , Sensors and Audio is yet to detect. Here is a point, To detect all  Kinect elements, device need some high power supply. For that you need to plug the power supply to your Kinect Device from external Power Source. This will enables windows to detect all the components of Kinect Devices.

Here is the Quick Video for the Device detection.

Kinect Device Detection : A Small Clip Recorded

Test Your Device

You have done with setup and installation. Let have a quick test your device.  Kinect SDK installs few sample application , Sample Skeletal Viewer is one of them. Just run that application, you will able to see your view in Depth View Skeletal View and Camera View.

If all of them are coming up. Your are all set to start development.

What else Kinect SDK installed for Developers ?

Yes, Kinect SDK also installed a best resource to learn Kinect SDK Development and Explore the APIs. This installation contains, Kinect SDK API Reference file. I learned most of the things from here itself.

How Application Interacts with Kinect

You have already installed SDK and Kinect Setup properly . So before start with development, let have a look how Application interacts with Kinect Devices. Kinect SDK Installed set of API to interact with Devices, You application will talk to those APIs and APIs will talk to Devices. Below images shows the same flow.

Staring With Application Development  :

Finally all the setup are done.  Let’s  have start some development with Visual Studio 2010 and create a small application  which will Initialize Kinect Sensor and display the Unique device name

Fire a new instance of Visual Studio, Select New Project Option from file Menu and Select “WPF Application” Template , Give the name as “MyFirstKinectDemo”

Click on OK, It will create a blank WPF Application for you.  Before going ahead, first lets design the UI as show in below

Below code snippet  is the XAML markup for the above design. Well, its very simple.

Now it’s time to interact with Kinect SDK API’s. To start with, you need to first add the reference of  Kinect SDK assemblies. Navigate to solution explorer, Right Click on the Project and Select “Add Reference”

The assembly you need to add is “Microsoft.Research.Kinect.dll” ,  You can search for Kinect keyword in the Assembly search text box to get it faster.

This will add Microsoft.Research.Kinect.dll as reference to your project. The top level view of this assembly  in Object Explorer given as below. These two are the different segment of Kinect APIs.

If you want to interact with NUI ( Natural User Interface)   API  like camera, sensors, Skeleton viewer  you have to use the below namespaces.

If you want to interact with Kinect Audio Array, you have to include

For this application, we will be using NUI API hence we will be adding below namespaces with our code.

using Microsoft.Research.Kinect.Nui;

First of all you need to define the runtime of Kinect as shown in below,  this represents the instance of Kinect Sensor.

After that,  initialize the runtime with the options you want to use. Below are this Runtime options which Kinect Supports

In the next article I will discuss more about the runtime options. For this example,  use RuntimeOptions.UseColor to use the RGB camera.

Below is complete Code snippet for Initialize and Uninitialized the Kinect Device.

    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        /// <summary>
        ///
        /// </summary>
        Runtime nuiRuntime = new Runtime();

        /// <summary>
        /// Initializes a new instance of the <see cref="MainWindow"/> class.
        /// </summary>
        public MainWindow()
        {
            InitializeComponent();
        }

        /// <summary>
        /// Handles the Click event of the buttonInitialize control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
        private void buttonInitialize_Click(object sender, RoutedEventArgs e)
        {
           // Intialize Kinect Device with UseColor Runtime Option
            nuiRuntime.Initialize(RuntimeOptions.UseColor);
            MessageBox.Show("Device Runtime Initialized");

            //Get the Camera Device Name
            labelDeviceName.Content = nuiRuntime.NuiCamera.UniqueDeviceName;
        }

        /// <summary>
        /// Handles the Click event of the buttonUnInitialize control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
        private void buttonUnInitialize_Click(object sender, RoutedEventArgs e)
        {
            // Uninitilize Runtime
            nuiRuntime.Uninitialize();
            MessageBox.Show("Device Runtime UnInitialized");
        }
    }

That’s all, Run the Application and Click on “Initialize Kinect Runtime” , your application will initialize a runtime of Kinect device via SDK APIs and you will get below message as written in code.

After the acceptance of the initialize message, you will get the Unique Camera device name.

Clicking on “Uninitialized Kinect Runtime, button will execute the below code to uninitialized device

Download Sample

Well, That’s all . To Summarize the stuff what I have discussed till now is, setting up your development environment, installing Kinect SDK, Detecting  the devices and a small application to initialize the  Kinect devices. This is only the beginning, we will talk a lot more about API and will start with something new in my next post.

More Study and Reference

Thanks !

Abhijit

Let’s consider we have below class for Customer entity. We will create a list of Customers and based on the value of “ShowURL” we are going to display the Web Sites URL.

    /// <summary>
    /// Customer Class
    /// </summary>
    internal sealed class Customer
    {
        public int ID { get; set; }
        public string Name { get; set; }
        public string WebSite { get; set; }
        public bool ShowURL { get; set; }
    }

Here’s the code snippet for creating List and binding with GridView Control.

  /// <summary>
        /// Handles the Load event of the Page control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
        protected void Page_Load(object sender, EventArgs e)
        {
            List<Customer> emps = new List<Customer>()
            {
                new Customer{ID=1, Name="Customer 1",WebSite="http://abhijitjana.net",ShowURL=true},
                new Customer{ID=2, Name="Customer 2",WebSite="http://abhisheksur.com",ShowURL=false},
                new Customer{ID=3, Name="Customer 3",WebSite="http://jebarson.info" ,ShowURL=true},
                new Customer{ID=4, Name="Customer 4", WebSite="http://atulvarma.com", ShowURL=false}

                };
            myGrid.DataSource = emps;
            myGrid.DataBind();
        }

In this example we are going to illustrate the binding with TemplateField, so here is the design view of GridView where we have Two column with two different template field. First one is the container of Name and second on is the container of Web Site.

Below images shows the output of the above binding.

Well, as of now all the site link are getting displayed in the GridView. But we have to display the links based on the value of “ShowURL”  field.

The most common solution we can find is “set visibility during GridView RowDataBound Event” as shown in below

/// <summary>
        /// Handles the RowDataBound event of the myGrid control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Web.UI.WebControls.GridViewRowEventArgs"/> instance containing the event data.</param>
        protected void myGrid_RowDataBound(object sender, GridViewRowEventArgs e)
        {
            if (e.Row.RowType == DataControlRowType.DataRow)
            {
                Customer cust = e.Row.DataItem as Customer;
                if (!cust.ShowURL)
                {
                    LinkButton lnkWebURL = e.Row.FindControl("lnk") as LinkButton;
                    if (lnkWebURL != null)
                    {
                        lnkWebURL.Visible = false;
                    }
                }
            }
        }

Above code will hide the link button from the GridView as shown in below image.

Well, do we really need to override myGrid_RowDataBound() for this small task ? Can’t we do it using Binding Expression. One similar question had  asked over  at Code Project and I am going to share the answer  which I have provided .

We can use Operator with in Bind Expression. Hence, we can set the visibility of Control using Binding Expression. We really don’t need to write code in RowDataBound just set the visibility of LinkButton as shown in below

How it works ?

This will do exactly we did in myGrid_RowDataBound() event. But we followed a different approach.  Eval(“ShowURL”) find evaluate the value of ShowURL From the GridView data source and then set the properties of LinkButton Visibility.  Based on the visible properties of LinkButton, controls renders on page.

We can also use any conditional operator with in the  Binding Expression as well as shown in below

That’s all. Very simple, but this will give you some idea to think on using Binding Expression in different ways as well.

Hope this helps.

Cheers !

Aj

1. Working with AggregateCatalog in MEF
2.  Working with DirectoryCatalog in MEF
3. Working with AssemblyCatalog in MEF
4. Working with TypeCatalog in MEF
5. How to use DebuggerTypeProxy while debugging your sensitive Type
6. ASP.NET Calendar Control as Outlook Calendar
7. Initialize assemblies using PreApplicationStartMethod for ASP.NET 4.0 Application
8. Async Lambda Expression
9. Playing with ASP.NET List Controls using jQuery
10. How to allow user to input html in ASP.NET MVC?
11. Using Mutex to avoid deadlocks
12. Writing inline Code in WPF
13. What is SynchronizationContext all about
14. ThreadLocal storage in .NET
15. Barrier in .NET 4.0
16. Use of Interlocked in Race Condition
17. Call ASP.NET Page Methods using your own AJAX
18. Use of SpinLock for ThreadLocking
19. Using ReaderWriterLock over Monitor for Thread Locking
20. What is the use of IsBackground property of Thread?
21. Enable Address Level Debugging in Visual Studio
22. Get List of all Control Types in WPF
23. How to apply simple faded transparent effects on WPF controls ?
24.  Use Visual Studio Server Explorer to Add New or Existing SQL Server CE Database
25. Co-Ordinated Thread Shutdown with and without using CancellationTokenSource
26. Generate thousand of request
27. Writing a Stretchable ContentControl in WPF
28. How to Retrieve WPF Visual Tree Programmatically ?
29. What is Visual Tree and Logical Tree in WPF?
30.  Dealing with HWND in WPF
31. Hosting a WPF control inside a Windows Form

To get regular updates visit http://dailydotnettips.com and follow @dailydotnettips at Twitter

Installing Assembly to the  GAC requires admin privileges. Visual Studio must be started with elevated rights.  From the Project Properties Window  Page of the class library ( which you want to put into GAC) , Navigate to “Build Events” Tab.  Build Events tab having two command line option for both Pre-Build and Post-Build event.  We will be configuring the Post Build Event to install the dll into GAC because we want to put the dll into GAC after the successful build.

Below is the  typical syntax for installing Assembly into GAC  from command prompt which we used generally

gacutil [options] [assemblyName | assemblyPath | assemblyListFile]

Visual Studio Build Events also use the same syntax. But, the interesting part is the Location of GAC.  Yes, the GAC was split into two. We all knows, .NET 4.0 introduced CLR 4.0. NET Framework 2.0 and .NET Framework 3.5 targeted to  CLR 2.0  and  .NET Framework 4.0 is targeted to CLR 4.0. The GAC is now split into private GAC’s for each runtime that targeted differently to CLR 2.0 and CLR 4.0 . I will recommend you read the article  “Understanding the CLR Binding” for more details.

Let’s assume, the Assembly is targeted to .NET 4.0 . To Add this Assembly, we have to specify the below Pre-Build Command.

"%ProgramFiles%\Microsoft SDKs\Windows\v7.0A\bin\NETFX 4.0 Tools\gacutil.exe"  /i "$(TargetPath)"

$(TargetPath) is a pre defined macros that returns the dll full path.

Ok, that’s all. Save the file and build  your class library.  You are expecting the assembly to be installed into GAC.  But after build  you will get below error indicates something went wrong.

From the error message it is difficult to understand what’s went wrong. In this situation Output window is very useful. Below is the captured details by out put window.

Well, if you know what is assembly and what is shared assembly, you must be knowing about  Strong name.  A Shared Assembly must have a strong name to uniquely identify.  Read more about strong name

So, let’s quickly create a strong name using  Strong Name tool . Open Visual Studio Command Prompt and type the below command.

sn –k  > c:\mytestkey.snk 

This will generates and writes the public and private key pair in C:\mytestkey.snk file. If you are interested, you can read Strong Name Tool (Sn.exe) for further details on Strong Name Tool.

Once you have done with the snk file generation, go back to visual studio >  Properties Pages > Signing Tab.  Enabled the “Sing the assembly” option. This will allow you to choose the “snk” file.

From the “Choose a strong name key file” dropdown, browse the newly generated snk (mytestkey.snk) file.

That all, now you can build the application and check the “Output window” as well for details.

Check for your GAC, you will find your assembly installed there.

For .NET Framework 3.5, if you have use below command as post build event

C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\bin\gacutil.exe"  /i "$(TargetPath)"

So you really don’t not need to run gacutil command from command prompt ever time after successful build. Visual Studio will take care of each and every thing automatically. For this type of scenarios, Output window is very important, because you can get details of the execution from here only. Similarly like Post-Build event, you can use Pre-Build event to remove some assemblies from GAC.

That’s all.

Hope this will help !

Cheers !

Aj.

[New Blog Post] Install a shared Assembly to the GAC as post build event from Visual Studio wp.me/ppvPE-Mq #vstudio #gac #assembly—
Abhijit Jana (@AbhijitJana) August 24, 2011