This book turned out to be a nice and quick introduction of Razor view engine. The approach of the book made it very easy to follow and learn. This book start with creating a basic ASP.NET MVC project and quick introduction to the ASP.NET MVC. This also talks about difference between Razor and ASP.NET View Engine. Slowly it will take you through inline codes, block codes, mixed codes, conditional and repetitive statements, layouts and nested layouts, directives, scaffolding, and model directives. This books also covers the helpers with extension also gives and quick overview of partial views.

The content of the book looks like :

• Creating the project (Should know) :
  • In this section author discussed about the creation of ASP.NET MVC Project and ran through the basic introduction ASP.NET MVC and a very quick introduction of Razor View Engine and how this differ with ASP.Net View Engine. 
• Fundamental Razor syntaxes (Must know) :
  • A quick deep dive into code expressions, code block, expressions, mixed code expressions, conditional statements and  basic loops are covered in this chapter. In this chapter, Abhimanyu also explained how the language parsers works in different situation with some nice example.
• Razor layout pages (Become an expert):
  • Here author introduces all the concepts of layout pages, nested layout pages, RenderBody, RenderSection. All the concepts are clearly explained with examples.
• Models in Razor (Must know):
  • Talks about model directives, scaffolding views – and best thing is, author managed the things to explain very well using a sample “ToDo” application.
• Razor helpers (Must know) :
  • Discussed about helpers with extension methods, declarative syntax, and standard helpers and how to apply them in different scenarios.
• Partial views (Should know):
  • This section explains about render partial views using Partial, RenderPartial, Action, and RenderAction helper methods.

My Thoughts

Here is the couple of points I wants to highlights about the book, of course both positive and negative points. 

• Very nice introduction of Razor View Engine for beginners and for anyone who wants to recap the Razor view engine very quickly.
• Each chapter is very well through out and steps you through the details of every syntax and the out puts.
• Concepts are clearly written and output are explained very nicely with screen shots and annotation.
• Easy to learn and grab things. Clearly written with very simple language and examples.

• In the starting of the book, few basic thing are explained ( loops, statements ) in too much details  and looks very repetitive. Where as in the end, couple of important concepts are explained in hurry. Author could have adjusted the pages for important concepts.

Overall Rating 

All in all this book is a really nice introduction of Razor View Engine with ASP.NET MVC and well presented. I can recommend it to any one who is new in the technology or want to quickly recap.

Disclosure Note: The book was provided to me free by the Author to read and review. This is my own review. Neither the publisher nor the author has seen it before I published it, nor prompted me or influence me in any way.

I will  be delivering a session on “Kinect for Windows SDK” and will talk about how we can build a gesture enabled and speech recognized application; this is what we called building Natural User Interface (NUI) application. I will also walk you through with different features of Kinect SDK such as capturing Infrared data Stream, Getting Sensor Accelerometer data, tracking human body joints and something around Face Tracking. 

Overall, this is going to be really fun full session with lots of learning.  I will definitely give away couple of eCopy of my  Kinect for Windows SDK Programming Guide book.

Not only the Kinect, there are couple of more interesting session on Mobile Services and Browser Security. Here is the complete agenda.

This is absolutely free event,  Register here : http://mugh2013ugmeet-feb.eventbrite.com/#

Looking forward to see you.

Cheers,
Abhijit

The IR emitter and the depth sensor are works together to produce the depth data, where each pixel comprises the information about the distance between the sensor and the object within the Kinect view area. The IR is invisible to the human eye as it has a longer wavelength than the highest wavelength that a human eye can see in a spectrum. This IR enables Kinect to see in the dark as well.

Similar like to the color, depth and skeleton stream data, Kinect SDK also exposes the APIs for capturing the IR data stream. You can capture images in low light conditions, by reading the infrared stream from the Kinect sensor. This will also help you to calibrate other camera with the Kinect sensor. Let’s have a look how to capture the IR data stream using Kinect for Windows SDK.

Capturing the IR Data Stream

The Kinect sensor returns 16 bits per pixel infrared data with a resolution of 640 x 480 as an color image format, and it supports up to 30 FPS. Following are the couple of images ( taken in a complete dark room) that captures from IR stream data.

You cannot read color and infrared streams simultaneously, but you can read depth and infrared data simultaneously. The reason behind this is that an infrared stream is captured as a part of a color image format.

Capturing IR stream data is as simple as capturing a color image stream, as the SDK returns the infrared stream as a part of the color image stream data. The only changes are required on ColorImageFormat and PixelFormats.

First, enable the ColorStream with the image format type of  InfraredResolution640x480Fps30 as shown in below.

this.sensor.ColorStream.Enable(ColorImageFormat.InfraredResolution640x480Fps30);

Then with in ColorFrameReady event handler, set the PixelFormats to Gray16 while creating the bitmap source as assigning it to image control ( say named as cameraControl).

this.cameraControl.Source = BitmapSource.Create(imageFrame.Width, imageFrame.Height, 96,96,PixelFormats.Gray16,null, pixelData, imageframe.Width * 2);

You can also use the WritableBitmap to write it as pixels as well.

Controlling the IR Emitter

You can also turn off the IR emitter using the KinectSensor.ForceInfraredEmitterOff property. By default, this property is set to false. To turn the IR light off, set the property to true.

ForceInfraredEmitterOff  will only work with Kinect for Windows Sensor. Not Kinect for Xbox Sensor.

You can read a bit details about ForceInfraredEmitterOff    here .

Let’s put everything in a single solution and see how to in dark / night/ low light using Kinect. We are going to build a “Night vision camera Using Kinect”..

Building a simple “Kinect Night Vision Camera”

Setup a new Visual Studio project by following the below steps.

1. Start a new instance of Visual Studio.
2. Create a new project by navigating to File | New Project.
3. You will see the New Project dialog box. Choose Visual C# as our development language, select WPF Application Template, and type the name as KinectNightVisionCamera
4. From Solution Explorer, right-click on the References folder and select Add References.
5. Include a reference of the Microsoft.Kinect assembly.

Open the “MainWindow.Xaml” file from the solution explorer and use below xaml snippet for design a very basic UI for the camera.

<Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="40"></RowDefinition>
            <RowDefinition></RowDefinition>
        </Grid.RowDefinitions>
        <StackPanel Background="LightGray">
            <Label Content="Kinect Night Vision Camera" VerticalAlignment="Center" HorizontalAlignment="Left" FontSize="20" Foreground="Black" />
        </StackPanel>
        <GroupBox Grid.Row="1"  Height="231" HorizontalAlignment="Left" Margin="17,16,0,0" Name="groupBox1" VerticalAlignment="Top" Width="280">
            <Image x:Name="cameraControl" Stretch="UniformToFill"/>
        </GroupBox>
        <Button Name="buttonExit" Content="Exit" Grid.Row="1" Height="34" HorizontalAlignment="Left" Margin="307,206,0,0"  VerticalAlignment="Top" Width="81" Click="buttonExit_Click" />
        <CheckBox IsChecked="True" Checked="ControlIR" Unchecked="ControlIR" Content="IR ON/OFF" Grid.Row="1" Height="21" HorizontalAlignment="Left" Margin="308,172,0,0" Name="checkBox1" VerticalAlignment="Top" Width="76" />
    </Grid>

The basic design of the application will looks like similar to below image.

Now, open the MainWindow.xaml.cs file and first of all include the namespaces as

<br />using Microsoft.Kinect;

Next task for building the applications are follows:

1. Getting the sensor object and enable the Infrared stream
2. Start the sensor.
3. Handle the stream event handler.

Here is the complete code block.

KinectSensor sensor;

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

        /// <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="RoutedEventArgs" /> instance containing the event data.</param>
        void MainWindow_Loaded(object sender, RoutedEventArgs e)
        {
            if (KinectSensor.KinectSensors.Count > 0)
            {
                this.sensor = KinectSensor.KinectSensors.Where(kinect => kinect.Status == KinectStatus.Connected).FirstOrDefault();
                this.sensor.ColorStream.Enable(ColorImageFormat.InfraredResolution640x480Fps30);
                this.sensor.ColorFrameReady += new EventHandler<ColorImageFrameReadyEventArgs>(sensor_ColorFrameReady);
                this.sensor.Start();
            }
            else
            {
                MessageBox.Show("No Device Connected");
                this.Close();
            }
        }

/// <summary>
/// Handles the ColorFrameReady event of the sensor control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="ColorImageFrameReadyEventArgs" /> instance containing the event data.</param>
        void sensor_ColorFrameReady(object sender, ColorImageFrameReadyEventArgs e)
        {
            // Get the current image frame from sensor.
            using (ColorImageFrame imageFrame = e.OpenColorImageFrame())
            {
                // Check if there is any frame drop
                if (imageFrame == null)
                {
                    return;
                }

                // get the frame pixel data length
                byte[] pixelData = new byte[imageFrame.PixelDataLength];

                imageFrame.CopyPixelDataTo(pixelData);

// note that stride has been set to imageFrame.Width*2, as its a 16bits/pixel
                cameraControl.Source = BitmapSource.Create(imageFrame.Width,
                    imageFrame.Height,
                    96,
                    96,
                    PixelFormats.Gray16,
                    null,
                    pixelData,
                    imageFrame.Width * 2);
            }
        }

If you run the application, you will find the sensor is returning a gray scale steam with many dots, which is nothing but the IR dots.

Handle the ForceInfraredEmitterOff  property by using following code snippet. The ControlIR() method is called from the checkbox’s checked and unchecked events. ( Below code will only work with Kinect for Windows Sensor. If you are using Kinect for xBox Sensor you will get an InvalidOperationException with message “The feature is not supported by this version of the hardware”,

/// <summary>
/// Controls the IR.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="RoutedEventArgs" /> instance containing the event data.</param>
        private void ControlIR(object sender, RoutedEventArgs e)
        {
            CheckBox chkbox = sender as CheckBox;

            if (chkbox.IsChecked == true)
            {
                this.sensor.ForceInfraredEmitterOff = false;
            }
            else if (chkbox.IsChecked == false)
            {
                this.sensor.ForceInfraredEmitterOff = true;
            }
        }

Finally, in the button exit close the application and before closing, make sure you are turning the sensor off if it is running.

/// <summary>
/// Handles the Click event of the buttonExit control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="RoutedEventArgs" /> instance containing the event data.</param>
        private void buttonExit_Click(object sender, RoutedEventArgs e)
        {
            if(this.sensor !=null && this.sensor.IsRunning)
            {
                this.sensor.Stop();
            }
            this.Close();
        }

Quick Video – Kinect Night Vision Camera

Download Sample Application With Source Code

Download the “Kinect Night Vision Camera Application” (KinectNightVisionCamera – SDK v1.6.zip)from the location http://abhijan.me/VSPaYD

Thanks.
Abhijit

Get the Infrared data stream and Control the IR Emitter of Kinect for Windows . #KinectforWindowsSDK #Kinect #kinectSDK abhijan.me/13l7lMe—
Abhijit Jana (@AbhijitJana) January 11, 2013

My Twitter Handler : @abhijitjana
Email Me : abhijitjana@outlook.com
My Kinect Book : Kinect for Windows SDK Programming Guide

Wish you and your family a very happy and prosperous new year 2013.  May this new year bring many new opportunities your way to explore every joy of life. I Hope this new year fills your life with happiness and perfect health always, much more success and happiness. Be Safe ! Stay Safe

As we wind up with year 2012, I would like to express my sincere thanks to all the visitors, readers, followers of my blog for their encouragement, feedbacks and support. 

Many Thanks,
Abhijit

Quick Overview:

• Building application using Kinect for Windows SDK.
• Covers the Kinect for Windows SDK v1.6
• A practical step-by-step tutorial to make learning easy for a beginner.
• A detailed discussion of all the APIs involved and the explanations of their usage in detail
• Procedures for developing motion-sensing applications and also methods used to enable speech recognition

What you will learn from this book

• Understand the Kinect sensor in terms of a device, different components, and how they work.
• Step by step installation guide of SDK, troubleshooting tips and development environment setup.
• Reading the Kinect device information, monitoring and notifying the sensor status change.
• Automatically adjust the sensor elevation angle
• Understand different approaches of capturing data stream from Kinect sensor.
• Learn the uses of color, depth and IR data and how to leverage them in your applications.
• Use skeleton-tracking for interactive applications and leveraging the applications to gesture-enabled application
• Understand usages of Microphone array and build speech-enabled applications with Speech API
• Develop applications using Multiple Kinects
• Understand how to design cross device application with Kinect
  

  What This Book Covers

  • Understanding the Kinect Device   [ Download the PDF version of this chapter ]
    

    Introduces Kinect as a hardware device. You will get an insight into the different components that make up Kinect and the technology behind this device, which makes the components work together. This chapter will also give an overview of the difference between Kinect for Xbox and Kinect for Windows sensor. You will also become familiar with different possibilities of domain specific applications that can be developed using the Kinect sensor.

  • Getting Started
    

    Introduces the Kinect for Windows SDK, its features, and how to start working with the Kinect sensor. In this chapter, you will get to know about the requirements for preparing your development environment. This will also walk you through a step-by-step guide for downloading and installing the SDK. You will delve into the installed components to verify that everything is set up properly. This chapter will also provide you with a quick lap around the different features of the Kinect for Windows SDK as well as introduce the Kinect for Windows Developer Toolkit.

  • Starting to Build Kinect Applications
    

    Explains the step-by-step process of building your first Kinect-based application. You will understand how applications interact with the Kinect sensor using the SDK libraries. This chapter will give you an in-depth guide on how to start building Kinect applications using the Kinect for Windows SDK and Visual Studio. You will also learn how to deal with applications when there is any change in the device status.

  • Getting the Most out of Kinect Camera
    

    Getting the Most Out of Kinect Camera, covers the in-depth discussion of the Kinect color camera and how to use it. In this chapter, you will learn about the different types of image streams and different approaches to retrieve them from the Kinect sensor. You will get an understanding of Color camera stream pipeline and its events. You will also explore the different features of the Kinect for Windows SDK that control the color camera and process the color data. This chapter will give you an understanding of processing color images and applying different effects to the captured images and how to save the image frames. You will also learn how you can use the Kinect camera to capture images in low light.

  • The Depth Data – Making Things Happen
    

    Explores the fundamentals of the Kinect depth sensors and how they produce depth information. This chapter describes how to work with object distances and player indices from the captured depth data. You  will also learn about the capturing of data using the near mode and also get a quick view of generating 3D depth data.

  • Human Skeleton Tracking

  Describes how a Kinect sensor tracks the human skeleton and how you can leverage the features of the Kinect for Windows SDK to play around with tracked skeletons and joints. You will also learn how to change the sensor elevation angle based on the player position. This chapter also explores how skeletons can be tracked in a seated mode. You also learn about details of the skeleton joints and bone hierarchy. The sample application in this chapter will help you to understand the APIs for skeleton tracking in better ways such as using Kinect as an intrusion detector. At the end of this chapter, you will be familiar with a few debugging tips and tricks to boost your development speed.

  • Using Kinect’s Microphone Array
    

    Introduces the microphone array that captures and processes the audio signal. You will learn why Kinect uses an array of microphones rather than a single microphone. In this chapter you will get an insight into the Kinect audio processing pipeline that helps Kinect to capture good-quality audio signals and makes Kinect a highly directional audio device. This chapter provides you with information on how to capture and record audio signals using the Kinect microphone array and process the audio data for better quality. You will also learn about different concepts such as Noise Suppression, Automatic Gain Control, Echo Cancellation, and Beam forming.

  • Speech Recognition

  Introduces the building of speech-enabled applications using Kinect. You will explore how speech recognition works and how Kinect’s microphone array helps Kinect to recognize human speech. This chapter also shows how you can use Kinect as the default speech recognition device for your PC. You will also learn about the Microsoft Speech API and how it is integrated with Kinect for Windows SDK, which helps us to build speech-enabled applications.

  • Building Gesture-controlled Applications

  Building Gesture-controlled Applications, describes how to build applications that can be controlled by human gestures. You will learn different approaches for recognizing gestures and how to apply these approaches in the form of programs to build motion-sensing applications using the Kinect sensor. This chapter will also help you understand how to build some gestured-enabled controls.

  • Developing Applications Using Multiple Kinects

  Explains how multiple Kinect sensors can be placed together and used to build applications. This chapter describes how to set up environments for developing applications using multiple Kinects and walks you through building applications by reading data from multiple devices. You also learn how multiple Kinects work together and different scenarios where multiple Kinects can be used, along with the challenges while developing applications using multiple devices.

  • Putting Things Together

  Introduces us to more advanced developments using Kinect by integrating it with other devices such as Windows Phone, microcontrollers, and so on. This chapter addresses how we can take things up from Kinect to Windows Azure and control the Kinect sensor using Windows Phone via Windows Azure. You will also learn how Kinect can be integrated with the Netduino microcontroller and how you can use a Kinect device for face tracking.

I would like to thanks all of you for your fantastic response on my Kinect Tutorial, Kinect seminars and my other Kinect works, which actually encouraged me to put something more exciting and together in a form of book. Thanks to the Packt publishing for offering me the opportunity to write for them. I couldn’t have written this book without technical help of  the many people and the community. Over the past one year, I was fortunate enough to present many seminars and conference on Kinect. This helped me to interact with many developers, students who are really passionate about programming with Kinect. I also met with many professors who have been researching on computer vision and Kinect technology. I had a great time to talk to each an individual; I have learned a lot. Sincere thanks to the complete editing team, and the reviewers (Atul Gupta, Anoop Madhusdanan and Atul Verma) who helped me to identify and fill the gaps and improve the overall content of this book. My friend, Atul Verma, not only did the technical review of this book, he worked with me on creating demos, designing samples and reviewing each of the things that I did for this book. My friend Jebarson helped me a lot on various things while writing. Many thanks to Arka Bhattacharya for doing offline review of the book. Arka, not only did the review, he helped me to editing contents, given me any feedback.

I would like to thank many bloggers on the various Kinect topics and also the researchers who have been working and experimenting day in and day out with Kinect. On many occasions I have been reading theirs posts, research papers and referring to them while writing the book.

Finally, I have written this book based on my personal experiences, experiment, study, learning from others, peer coding and working on different assignments on Kinect. The information given in this book is my personal and does not reflect the opinions of my employers. If you find any mistakes or have some constructive feedback please drop me mails at abhijitjana@outlook.com. I will try my best to address then as earliest.

Being a community lover and an active blogger, I have been writing blogs, participating in different forums and seminars for the last couple of years; but this is the first I am putting something in the form of book. The credit goes to each one of you have been connected with me and have been my blog reader and supporter.

I would also like to take this opportunity to wish you and your family a very happy and prosperous new year 2013.

Best Regards,
Abhijit

It’s been few months I kept my self absent from the blogging due to some other priorities. I have couple of good news to share; will share with all of you very soon. I would like to express my sincere thanks to all the visitors, readers, followers of my blog for their encouragement, feedbacks and continuous support. Please keep visiting and share your feedback.

Wish you lots of love, joy and happiness.

Best Regards,
Abhijit

Background

Before we could pitch in, let me give a little background on how we decided to build this on our garage. Developer Conference 2011 on Hyderabad was scheduled on October 2011 and myself and Jebarson were looking forward to show something cool on our own interested areas. Jebarson was looking out for something on Windows Azure and Windows Phone while myself was fiddling around Kinect. Ran out of ideas we both met together and thought of integrating everything and that is when we came up with the idea of building our own home security. We started building this application as early as September 2011. And by now, we have already revised the application more than 5 times due to newer SDK release and also due to the addition of newer components.

Overview

So how does the solution work. You should place Kinect devices on the locations you want to secure and keep it connected to a high end PC capable enough to do a video encoding and up streaming. The Kinect devices will be run by a WPF application running on the PC which will look for any human intrusion. While there is no human intrusion, it will remain in “Patrol Mode” where it will upload pictures of its view on regular intervals to Windows Azure. These pictures can be monitored at any point of time through the application running on Windows Phone and Windows 8. Whenever there is an human intrusion detected the Kinect changes itself to “Intrusion Mode”; it then alerts Windows Azure and also starts streaming the video to the Smooth Streaming Server hosted on Windows Azure. The Azure notifies all the devices subscribed (Windows Phone / Windows 8 ) using a toast and will allow those application to view the live streaming. From your Windows Phone / Windows 8 app you can also control the Kinect device.

Windows Azure

Now that we are done with the overview of how the solution works, lets talk about how it is built. Starting with Azure, below is how the application hosted on the cloud.

Windows Azure Management Portal

The Windows Azure Management Portal is created using the default template provided from Windows Azure Toolkit for Windows Phone or Windows Azure Toolkit for Windows Phone. This management portal can be customized later on to support the needed services. To begin with, the management portal by default integrates with all the above mentioned blocks except for the Smooth Streaming server; which means the API which would require for all the communication with these components are already defined. Now lets go with the flow.

Custom WCF Service Methods

In order to support the WPF application running on the PC connected to the Kinect devices, we will expose a custom WCF method called “Upload” allowing the it to upload an object of type “Photo”.

The image is uploaded as a byte array along with the type (Patrol / Alert) and time. As soon as the WCF service gets the message, it serializes it to string and puts it into the blobs and also pushes it to queue with the expiration time set for 1 minute. This will help the user to see the latest picture from his home at any point of time.

Shared Access Signature Service

The portal derived out of the template would require the authentication done through the certificate along with a user name and password for the generation of the token. Internally the portal uses ASP.net membership authentication through which it authenticates the user and provides a mutually agreed token to the client. So doesn’t matter whether the Windows Phone, Windows 8 needs the access to the Azure, it will require this mechanism to get authenticated. The token then will be required to access any methods from the service.

Microsoft Push Notification Service

This service allows the solution to send a notification message to any smart device which is capable of subscribing / receiving push notifications. The application which is written in Windows 8 and Windows Phone subscribes itself for the notification as soon as application is run for the first time. All the device needs is an internet connection for subscribing / receiving the notifications. Once the Azure service receives an alert message from the Kinect, it sends a push notification to all the devices subscribed. The subscription details are stored in the Azure Tables by the management portal.

Smooth Streaming Server

Configuring this server in the Azure would be the toughest part but would be a cake walk if you understand how it is done. Azure Live Streaming on codeplex allows you to do this. The Web role will have a “Startup.cmd” file which will contain the command as below to install the Smooth Streaming Server on the Azure Server.

set msiexec=%systemroot%\system32\msiexec.exe
set appcmd=%systemroot%\system32\inetsrv\appcmd.exe

%msiexec% /i “%~dp0\IISMedia64.msi” /qn ADDLOCAL=ALL /Le startup_media.txt

exit /b 0

The setup file IISMedia64.msi has to be added to the project as a content. The service definition file for the azure will have the below tags

<Startup>
<Task commandLine=”startup.cmd” executionContext=”elevated” taskType=”simple”></Task>
</Startup>

This will allow the batch file to run once the web role starts up.

You will also require to add “.isml” files for configuring the uplink / downlink streaming end point. For more information on how to configure the streaming server in Azure, please follow the documentation. The kinect will up stream the compressed video stream to the uplink endpoint and once the video stream is available on the Azure, it will automatically be available on the downlink to have a live streaming.

Note: You can configure any number of instances for a downlink server but only one instance for uplink server.

AppFabric Service Bus

We are using the appfabric service bus as a remote endpoint for a WCF service hosted in the application which is connected to the device. This will allow anybody to control the Kinect device like tilting just by sending a message to the WCF endpoint. This will eliminate the need of a static IP / DNS and the firewall overheads which may incur.

In our application there is a method exposed called “SendMessage” by the WCF hosted in the WPF application running along the Kinect devices. Once Windows Phone / Windows 8 sends a command to this method namely “up/down”, the device tilts as per the command.

Now that we have talked enough about Azure, lets talk a little about Kinect on how it is going to act as a watch dog for the solution.

Kinect for Windows

Kinect works as Watch Dog at your home which is connected with Windows Azure. The application was built on Kinect for windows SDK ( V 1.0) . We have used the Skeleton detection features to detect the human body motion.  As we have already mentioned by default Kinect will  be in “Patrol mode” , where it will upload the image with every 10 sec of interval and if there is any skeleton detection by Kinect sensor, it will start  the streaming.  We have used the expression encoder SDK to do the stream from application.  Below are the list of components which we have used in WPF Client application.

Below are the very top level view of code block  used for detection of skeleton and uploading it to azure.

Find if Skeleton is tracked and then set a global variable which is being used across the application.

if (this.skeletonData.Where(item => item.TrackingState == SkeletonTrackingState.Tracked).ToList().Count > 0
{
Global.IsSkeletonTracked = true;
}

Create a patrol type image is there is no Skeleton otherwise send the alert image.

if (Global.IsSkeletonTracked)
{
photo  = newPhoto() { CreatedOn = DateTime.Now, Image = filesbyte, Type = PhotoType.Alert };
}
else
{
photo = newPhoto() { CreatedOn = DateTime.Now, Image = filesbyte, Type = PhotoType.Patrol };
}

The type of Photo is defined with our service contract and we are uploading the images as bellow:

KinectReceiverClient client = newKinectReceiverClient("BasicHttpBinding_IKinectReceiver")
ServicePointManager.ServerCertificateValidationCallback = ((obj, certificate, chain, sslPolicyErrors) => true);
client.UploadPhoto(photo);

Windows Phone

As I mentioned earlier, Windows Phone will act as one of the end user device in this solution. To interact with Azure easily and securely, we will be using the Windows Azure Toolkit for Windows Phone client. As mentioned in the Azure, the windows phone app will authenticate itself against the Azure on the start up using a user name and password signed by the certificate. Once the application is authenticated, the app in the first screen will show the latest pictures which is peeked from the queue. Remember that these images are pushed to the cloud by the Kinect in the “Patrol” mode.

When there is an intrusion, the Windows Phone receives a toast notification. There is no need to keep the application running / keep your phone unlocked for you to see the notification as the Windows Phone takes care of all the services needed for listening to the notification. Upon tapping the notification, you will be navigated to the page where you will see the live stream through the Multimedia Player for Windows Phone streaming through the downlink url.

Windows 8

The metro app developed on Windows 8 runs pretty much the same way as Windows Phone except that it uses Windows Azure Toolkit for Windows 8. Since metro apps also supports the notification service, it’s the same functionality you will require to implement.

Application Functioning on Patrol Mode

Application Functioning on Intrusion Mode

Application Functioning on Accessing Kinect Remotely

We haven’t shared the code here while we have sharing everything that you will require to build this application. We would encourage to try building the application with all the knowledge we have shared. If you require any help on building the same, please do drop a note to us and we will be more than happy to help you.

Resources

• Windows Azure
• Windows Phone
• Windows 8
• Kinect For Windows
• Windows Azure Toolkit for Windows Phone
• Windows Azure Toolkit for Windows 8
• Windows Azure Live Smooth Streaming

Showcased

• Multiple events inside Microsoft.
• Developer Conference Hyderabad (Oct 2011)
• TechEd India 2012 (Jan 2012)

Check Out Recorded Session from TechED India 2012

Cheers !

Aj

My Twitter Handler : @abhijitjana
Email Me : abhijitjana@outlook.com
My Kinect Book : Kinect for Windows SDK Programming Guide

For the presentation we have developed a proto solution for Home Security. Well let me explain how we have put all these technologies into action. The Kinect device will serve as a watch dog at the home which is connected to the Azure. The device will be uploading patrol images to the Azure on regular intervals. Once there is a human intrusion detected, the Kinect will send a alert to the Azure and also will start streaming the live video to the Smooth Streaming Server hosted on Azure. Once the Azure, receives the alert, it will send a notification using Microsoft Push Notification Server (MPNS) to the subscribed Windows Phones and Windows 8 Metro apps where you can watch the video streamed live from the Kinect. Well, that’s not the end, we will also demonstrate on controlling Kinect from Windows Phone / Windows 8 Metro app using Azure App Fabric.

We will be discussing all the technologies involved and the architecture of the complete solution extensively along with a live demonstration in the TechEd.

Session Title : Windows Azure meets Kinect, Windows Phone and Windows 8 Metro
Track : Windows Azure
Date : 21 March 2012 1415 Hrs. IST
Venue : LaLiT Ashok’s, Kumara Krupa High Grounds, Bengaluru – 560001

See you there !

Cheers !
Aj

TechEd India -Presenting On "Windows Azure With Windows Phone, Windows 8 Metro And Kinect" abhijan.me/ywl9IB #techedin @jebarson007—
Abhijit Jana (@AbhijitJana) March 13, 2012

Check out the Complete Agenda from here : http://mugh.net/vs11devday/agenda.html

Register for the event from http://mughvs11devday.eventbrite.com/

See you there !

Cheers !

Abhijit

I am presenting on “Coding for fun on Kinect” . During this1 hr. session, I will be talking about Kinect .NET SDK APIs and will be developing some cool application using Kinect for Windows SDK Beta 2. Yeah, something interesting!

I have few copies of  “SQL Server Questions & Answers” book by Pinal Dave and Vinod Kumar to give away during my session.  

Here is the complete agenda

It’s a free event, Register  here :  http://mughdeveloperday01.eventbrite.com/

Looking forward to meet !

Cheers !

Abhijit