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

[Note : I recorded a quick 3 min video on the same and  embedded at end . ] 

Start a new instance of Visual Studio 2010 and Open Performance Explorer  from Analyze Menu . Click on the “New Performance Session” icon.

This will create a new Performance session for you with two different folders, Reports  ( Which is the repository for all .vsp files ) and Targets ( Targets folder shows the binaries that are profiled in the  current session )

Now, here is the trick, Right Click on “Targets” folder  and Click on “Add Existing web Site…”

Below dialog will appear where have to provide the url of your application which is hosted on IIS.

Click on OK, you will find the associated file that targeted to your web application within the targets folder.

Now you can start profiling  by clicking on “Start Profiling” option from the Performance session context menu.

Now you can see your profiling being started and checkout the targeted process Id for profiling ( In Performance output window) . Yes,  it’s targeted to the  worker process (w3wp.exe )  for the application which is running at IIS.

Stop profiling when you are done with the navigation of your application, you will find the generated reports under reports folder.

Now you can inspect the performance report within your visual studio itself.

Here is a quick video

Here is few useful tips and tricks on profiling.

• How to enable Tier Interaction Profiling ( TIP ) in Visual Studio 2010 Profiler ?
• Highlighting Execution Hot Path in Visual Studio 2010 Profiler Call Tree
• Create Work Item in TFS for Specific Visual Studio 2010 Profiler Report
• Setting Up Noise Reduction Option for Performance Reports in Visual Studio 2010 Profiler
• How to change Default Performance Report Name in Visual Studio 2010 ?

Hope this helps.
Cheers !

Aj

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

You can View and download the slide from here,

Thanks  again for attending and sharing your feedback and great response. If you have question related with the session please drop me message over this post, will try to respond as early as possible.

Thanks !

Aj

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

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

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

Keeping track of out of scope object is not  new stuff in Visual Studio. You can use “Watch Window” to keep track of out of scope object while debugging by Creating a “Object ID”. Here is one of my old post which discussed about How to track an object which is Out of Scope while Debugging ?

Visual Studio 2010 DataTip also supports creating “Object ID” of objects. By using “Make Object ID” option we are informing Visual Studio Debugger to keep track of that object no matter it’s within scope or out of scope for the current context. Along with “DataTips” we can create “Object ID” either from Locals, Autos or from Watch Windows. Object ID is a integer number followed by a pound (#) sign. When we create Object ID for an particular object, Visual Studio Debugger ( CLR Debugging Services ) use an integer value to uniquely identify the object. This “Object ID” allows you to get the object details even if it is out of scope.

Let’s consider a simple example where we have a list of students and we are displaying them in a console.

On Run above code snippet will give output something like this

In the next step, we have set a breakpoint while displaying the information in console and Pinned the current Stud object which is the Students[0].

On the next iteration, pinned element will change  to Students[1] and similarly to Students[2] and Student[3] for rest other iteration.

Now, assume currently you are inspecting the object “Stud” in pinned DataTips which is referring “Students[1]” , at this point you want the value of  previous “stud” object which was point to “Students[0]. Well, don’t say that we have the value in Students list and we can check it from there, yes we can, but our objective is something different here.  Let’s focus on how we can retain the previous values of Stud object.

So now we are going to create an object ID for stud to keep the track.  How ? Well, with in DataTip, just right click on the object and select “Make Object ID”

This will add  a number with the pound (#) sign with in value field of Data Tips. That #number is the unique identifier of the marked object.

By referring the object Id we can get the value of Object at any point of time during debugging no matter of the scope of the object.  This is very simple example, but think about you want to keep track of some object information which are in some local method scope.

What next ? Iterate to next element, DataTip will show the element of Students[1] .

So where is our previous “Stud” object. To get that value, right click on “DataTips” and select “Add Expression”

This will create a placeholder for new elements with in DataTips.

Type 1# with in the new place holder and that’s all. You have the value of previous “Stud” objects.

Similarly you can create more “Object ID” to keep other variables as well. You can inspect that object in Immediate window as well

On a side note, you can  also use Visual Studio Memory Window to check if there is something exists on the particular Address or not.  You can navigate to Memory Window from Debug > Windows > Memory .

Note : The Memory window is available only if address-level debugging is enabled ( Tools > Options > Debugging )

Before create the Object ID, if you try to find out the address, you will get “unable to evaluate the expression” message.

On creation of Object ID, you will get the memory details of the Object.

I will suggest to give a look at my previous article  for details discussion on “Watch window and Object ID Creation”

To Summarize, By using “Make Object ID” option we are informing Visual Studio Debugger to Keep track of that object no matter it’s within scope or out of scope. When we create Object ID for an particular object, Visual Studio Debugger ( CLR Debugging Services ) use an integer value to uniquely identify the object. This “Object ID” allows you to get the object details even if it is out of scope. If you received the message “Can’t evaluate the Object Values” while working with “Object ID”, it means that Object has been garbage collected. This is another way where you can identify that an Object has been garbage collected.

Related Post :

How to track an object which is Out of Scope while Debugging ?

10 Tips you should know about “Watch Window” While debugging in Visual Studio

How to use out of scope object with in Conditional Breakpoint ?

Hope this will help !

Cheers !

Aj