Startup Weekend à Mons et Liège : 20 inscriptions offertes par le MIC pour les développeurs .NET !

15. September 2012 12:09 by Renaud in   //  Tags:   //   Comments (0)

Les prochains Startup Weekend en Belgique auront lieu à Mons le weekend du 19 octobre, et à Liège le weekend du 9 novembre.

Un Startup Weekend, pour les développeurs, c'est le défi de former/rejoindre une équipe pour donner vie à un projet en à peine 54 heures. Un projet qui ait du sens, avec un réel potentiel. Si vous vous rappelez cet article racontant mon weekend au premier Bemyapp belge, vous avez alors une idée de ce dont il s'agit. On met sur le tapis des idées, et on forme des équipes polyvalentes, faites de designers, de développeurs, et d'autres talents. Le Startup Weekend, en quelques chiffres, c'est « le plus gros incubateur de projets innovants au monde : plus de 580 événements, 90 pays, 300 villes, 56 000 participants, plus de 800 entreprises créées ».

 

S'inscrire pour Mons S'inscrire pour Liège

Personnellement je serai présent au moins à celui de Mons, et pourquoi pas à celui de Liège si mon emploi du temps le permet :) Vous aurez remarqué que l'inscription est payante (75€ pour les devs, et 60€ en early bid). Mais la super bonne nouvelle, c'est que le MIC de Mons va généreusement offrir l'inscription à 10 20 développeurs .NET prêts à relever le défi ! (10 places pour Mons, et 10 places pour Liège.) La seule condition, c'est d'être développeur .NET, et de s'engager à participer à tout le weekend. Bah oui, sinon on vous l'offre pour rien et ça empêche quelqu'un d'autre d'en profiter... Le nombre de place est assez limité, mais si ça vous intéresse, que vous êtes prêts à écrire des tas de lignes de code, et que vous êtes sûr de pouvoir venir, envoyez-moi un mail à renaud at mic-belgique.be, et je m'occuperai de votre inscription! Premiers arrivés, premiers servis !

TFS Preview – Le gestionnaire de version dans le cloud !

30. August 2012 09:08 by Renaud in   //  Tags:   //   Comments (0)

TFS Preview - TFS dans le cloud !

TFSPreview - Homepage

TFS Preview

Avez les sorties récentes et futures, Windows Phone, Kinect, Windows 8, ... Vous devez certainement démarrer un tas de nouveaux projets. Mais si vous hésitez encore entre plusieurs source controller, pourquoi n'essayeriez-vous pas TFSPreview.com ? TFSPreview, c'est Team Foundation Service Preview. Globalement, c'est Team Foundation Server (que vous connaissez déjà), mais as a Service. Vos projets sont maintenant hébergés dans le cloud et disponibles de n'importe où. Je vous propose d'y jeter un rapide coup d'oeil, histoire de vous décider :)

Création d'un compte TFSPreview

Tout ce dont vous avez besoin, c'est d'un Live ID ! Connectez-vous simplement avec votre compte live habituel. Vous serez alors invité à créer gratuitementun nouveau compte Team Foundation Service. Vous allez pouvoir donner un nom à votre compte, qui formera l'adresse publique de votre serveur !

TFSPreview - Création de compte

TFSPreview - Création de compte

 Ensuite, il faut créer un Team Project. Un Team Project n'est pas un "projet" au sens Visual Studio. Vous pourrez effectivement avoir plusieurs projets et même plusieurs solutions dans un seul Team Project.

TFS Preview - Portail

TFS Preview - Portail

 Pour finir, il reste à ajouter les membres de votre équipe si nécessaire. Renseignez simplement leur Live Id pour leur donner accès au serveur.

TFS Preview et Visual Studio 2012

A partir de Visual Studio, il est très simple de travailler avec TFS Preview. Au démarrage de VS, on va ajouter le nouveau serveur TFS que l'on vient de créer :

Vous allez devoir vous connecter avec votre Live Id encore une fois, et ensuite vous pourrez ajouter votre serveur. Les infos de connexions à TFS sont:

URL : [votrecompteTFS].tfspreview.com
Path/chemin : tfs
Port : 443
Protocol : https

  Utilisateurs de Visual Studio 2010 : pour prendre en charge TFS Preview, il est nécessaire d'avoir installé la SP1, et d'ajouter un petit correctif : KB2581206. (source) Lorsque vous vous êtes connectés au serveur, vous pouvez ouvrir le Team Project créé précédemment, et utiliser l'explorateur de contrôleur de sourcesde VS.

TFS Preview - Source Control Explorer

TFS Preview - Source Control Explorer 

L'inscription "Local Path : Not mapped" indique que vous le dossier sélectionné sur la gauche, dans l'arborescence de l'explorateur de sources, n'a pas d'équivalent chez vous, en local ! Il faut créer le mapping pour indiquer à Visual Studio où stocker votre projet. Après c'est simple, il suffit de parcourir les dossiers pour ouvrir la solution ou le projet sur lequel vous voulez travailler. Depuis l'explorateur de solution, vous pourrez récupérer les dernières versions d'un fichier ou de l'ensemble du projet, consulter l'historique d'un fichier, le comparer avec des versions précédents. Vous verrez également à côté de chaque fichier une icône indiquant si vous avez l'avez modifié, et donc s'il est nécessaire de faire un check-in.

VS 2012 - Checked-out/checked-in

TFS Preview - Checked-out/checked-in

Si vous êtes au beau milieu d'un refactoring de code, et que vous devez subitement changer de tâches, mais que le code sur lequel vous êtes occupés ne vous semble pas assez correct pour faire l'objet d'un check-in (ce qui implique qu'il sera récupéré par les autres développeurs lorsqu'ils récupéreront les derniers changements), vous pouvez décider de faire un shelve, plutôt qu'un check-in. Vos modifs seront alors envoyées au serveur, et vous pourrez à tout moment les récupérer pour continuer à travailler dessus, sans affecter le travail des autres. Cela peut également être pratique dans le cas où vous avez besoin d'aide sur un bout de code, et que vous aimeriez demander l'avis d'un autre membre de l'équipe. Vous pouvez à ce moment-là faire un shelve, et demander un review de votre code. Cela vous évitera ainsi de propager un code "cassé". Pour demander un review, tout est également intégré à VS et peut se faire depuis la vue Team Explorer. Vous n'avez qu'à indiquer quels membres doivent être notifiés, et ils verront, également à l'intérieur de Visual Studio, qu'un demande de review leur a été envoyée. Pour les travaux plus poussés, il est également possible d'utiliser TFS Preview comme serveur d'intégration continue.

TFS Preview entièrement gratuit

Alors oui, le service est pour le moment gratuit, parce qu'il s'agit d'une preview. Il n'y a pas encore beaucoup d'indications sur ce que coûtera le service par la suite, si ce n'est ce qu'on peut lire dans la FAQ :

Pricing

Q: Will the service always be free?

A: Full-featured accounts are available for free while the service is in preview. After that, there will be free and paid accounts.

Q: Will all the features I’m using today be free?

A: Some features will remain free after the preview is over. There will also be some features that will be free in preview (so we can iron out all the bugs), but afterward may only be available in paid offerings.

La bonne nouvelle donc, c'est qu'il restera toujours des comptes gratuits, qui seront sans doute suffisant pour gérer les petits projets personnels ! :)

Talk @ Café Numérique de Mons, Juin 2012

28. August 2012 19:08 by Renaud in   //  Tags:   //   Comments (0)

En juin dernier, j'ai fait une courte présentation au Café Numérique pour parler de mon objectif en tant qu'IT Evangelist au Microsof Innovation Center de Mons. La présentation était chronométrée : 20 slides de 20 secondes. La prise de vue a été assurée par Jellycube Studio !

Dans ce pitch, je parle de mon envie d'organiser des évènements dans la région de Mons, en collaboration avec les communautés Microsoft/.NET déjà existantes en Wallonie. Et c'est notamment suite à cela qu'on a organisé les Afterworks avec DotNetHub.

L’App’ero Windows 8 au MIC

28. August 2012 15:08 by Renaud in Events, Windows 8  //  Tags: , ,   //   Comments (0)

Je vous avais parlé dans un article sur  la rentrée des développeurs Microsoft du fait qu'on allait continuer à organiser des évènements au Microsoft Innovation Center Belgique. Alors on va commencer tout de suite !

Inspiré et motivé par les events organisés en France par la Communauté des Développeurs Windows 8, on a voulu en faire autant dans notre région Wallonne. N'hésitez pas à vous inscrire, c'est gratuit et ouvert à tous.

Venez nous montrer ce que vous savez faire, ou venez voir ce que les autres ont déjà fait. Notez qu'il est toujours tant de développer quelque chose juste pour l'occasion, et pour le fun :)

Téléchargez les outils maintenant (français)


L’App’ero Windos 8 est une initiative qui vise à faire découvrir la nouvelle plateforme de Microsoft d’un point de vue technique ! L’objectif est de rassembler des professionnels ou passionnés de l’IT, développeurs ou administrateurs systèmes, qui ont déjà ou ont l’intention de se lancer dans l’aventure Windows 8.

L’événement se tiendra au Microsoft Innovation Center de Mons, lors d’une soirée mêlant Apps Windows 8, et apéro ! :)

L'App'ero Windows 8

Les participants sont attendus le 26 septembre dès 18h. Des speakers (annoncés prochainement) viendront présenter Windows 8, ses particularités, et ses fonctionnalités, sous différents angles : développeur ou administrateur système.

Comme l’idée de l’événement est de rencontrer d’autres passionnés et de renforcer notre communauté en Wallonie, un concours sera organisé durant la soirée. Toute personne ayant développé une application Windows 8 pourra prendre la parole et présenter son travail sur une tablette Windows 8 aux autres participants qui voteront ensuite à main levée pour désigner la meilleure application. Le ou les gagnants seront sacrés Windows 8 App’Héros et gagneront le respect de la communauté ! :)

Pour vous inscrire, rendez-vous sur la page de l’événement : http://www.win8appero.be, et rejoignez-nous sur Twitter ou Facebook pour être tenu informé des nouveautés dans le programme et connaître les noms des speakers ;)

Un été pour développer une app Windows 8 !

5. July 2012 22:07 by Renaud in   //  Tags:   //   Comments (0)

Portail Windows 8

Si vous ne l'avez pas encore remarqué, le portail Windows 8 - comme la majorité des sites Microsoft - a fait peau neuve : http://www.microsoft.com/belux/msdn/metromap/ Ce site est le point d'entrée pour les développeurs qui souhaitent se lancer sur la nouvelle plateforme Windows 8. A vrai dire, le moment est plutôt bien choisi pour s'y mettre. Microsoft propose un tas d'opportunités durant l'été pour que vous puissiez être parmi les premiers à publier vos applications dans le Store, dès la sortie de Windows 8. Si l'aventure vous intéresse, commencez par suivre le lien ci-dessous et lisez la suite pour savoir pourquoi vous devriez vous lancer, et comment on peut vous aider :

Build your app NOW !

4 étapes pour Windows 8

 Microsoft vous propose de publier votre application en seulement 4 étapes :
  • Téléchargez les tools : tout est gratuit ! Vous pouvez tester la Release Preview de Windows 8, ainsi que Visual Studio 11 Ultimate, oui oui ! :)
  • Formez-vous : il y a déjà énormément de ressources en ligne, et vous trouverez ce qu'il vous faut en fonction du temps que vous avez à y consacrer. Par exemple :
  • Participez à un App Clinic : en avançant dans le développement de votre application vous pourriez avoir besoin de conseils UX, ou faire face à des problèmes plus complexes. Les App Clinics sont là pour ça ! Vous pourrez rencontrer des experts qui vous permettront de tester vos apps sur une large gamme d'appareils, vous donneront des conseils sur l'expérience utilisateur de votre application, les guidelines Metro, et feront en sorte que votre application soit au top pour entrer dans le Store !
  • Terminez avec un App Excellence Lab : une fois passé par l'App Clinic, et lorsque vous vous sentirez prêt, vous pourrez présenter votre app pour un Excellence Lab. Il s'agit d'un rendez-vous de 2 heures avec un expert de chez Microsoft qui vérifiera que votre application remplit toutes les exigences qualitatives. Si c'est le cas, vous recevrez alors un Windows Store Token qui vous permettra de publier votre application sur le Store de Windows 8 !
Le MIC vous propose également une raison supplémentaire : un appel à projets lancé récemment en partenariat avec AGC. Vous pouvez retrouver toutes les infos nécessaires dans cet article : Call for projects : Smart Mirror Device W8 applications. Si vous ne voulez pas vous lancer seul dans l'aventure, sachez que plusieurs évènements qui peuvent vous intéresser sont organisés durant l'été :
  • Le 10 juillet prochain aura lieu le Windows 8 Summer Camp au MIC Belgique. Il s'agit d'une journée de formation donnée par Loïc Bar, spécialiste des technologies Microsoft dont Silverlight, ASP.NET MVC, WCF, ... L'inscription est gratuite et peut se faire ici : http://events.mic-belgique.be/event/windows-8-camp
  • Ne manquez pas non plus le premier Summer App-a-thon Windows 8 ce 12 juillet. Il se tiendra à la côte, et plus précisément au Casino de Blankenberge ! Suivez ce lien pour vous inscrire ou avoir plus d'infos : Coding on the beach !
  • Si vous n'êtes pas trop plage, ou que vous êtes en vacances durant le mois de juillet, vous pouvez toujours vous rattraper le 8 août avec le deuxième App-a-thon qui aura lieu cette fois à Anvers : the Metro-politan App-a-thon !
Le MIC sera présent à chacun de ces évènements, donc n'hésitez pas à vous inscrire car vous ne serez pas seul ! Et si vous n'avez aucune idée de ce que peut-être un app-a-thon (ou hackathon), regardez plutôt l'article précédent : Un weekend au BeMyApp. Le MIC était de la partie, et l'ambiance était juste énorme ! Dans tous les cas, si l'idée de développer une application vous tente, n'hésitez pas à nous contacter par mail, sur la page Facebook du MIC, ou via notre compte Twitter... Nous serons ravis d'avancer avec vous !

Un weekend à la première édition du BeMyApp Belgique

5. July 2012 13:07 by Renaud in   //  Tags:   //   Comments (0)

Le weekend dernier, la première édition du BeMyApp Belgique a eu lieu à l'ICAB, un incubateur d'entreprises et espace de coworking situé à Etterbeek. Le BeMyApp, c'est l'occasion pour les professionnels et amateurs des technologies de se rencontrer, former une équipe, et réaliser un projet le temps d'un weekend. Au MIC, nous adorons ce genre de challenge ! Du coup, nous avons monté une petite équipe de développeurs prêts à ne pas dormir pendant tout un weekend, et nous nous sommes donnés rendez-vous le vendredi dès 18h. Une trentaine de personnes (parmi près de 100 participants au total) sont venues le premier soir présenter leur idée d'application, et ont tenté de trouver du soutiens auprès des designers et développeurs présents ce soir-là. C'est comme ça que nous nous sommes lancés dans le projet HowTo, imaginé par Anne Laure de Harlez. L'idée en quelques mots : une application de contenu Do it yourself simple et design. Les utilisateurs peuvent explorer les créations à la recherche d'idées, ou proposer leurs propres HowTo en maximum 5 étapes accompagnées de photos.

HowTo

Notre équipe était constituée de quatre développeurs .NET, un développeur Android, deux graphistes, et de l'initiatrice du projet. Après un moment de brainstorm pour préciser l'idée, nous avons pu nous lancer dans les joies du code !

HowTo en quelques mots par Anne Laure de Harlez

Notre application utilise un service web développé en ASP.NET MVC 4, utilisant les fonctionnalités des API Controller pour créer une API REST. Et pour offrir un maximum de performance et de scalability, le tout a été hébergé dans le cloud de Windows Azure ! Côte client, nous étions partis sur deux applications : une Windows Phone, et une Android, parce qu'en plus d'être scalable, notre service Windows Azure est évidemment compatible avec toutes les plateformes !

A l'intérieur du Nautilus / credit photo : BeMyApp Belgique

Martin Caezza, l'un des graphistes de notre équipe, a réalisé une vidéo qui peut donner une idée de l'ambiance durant ce weekend !

Le développement a bien avancé, et l'identité visuelle de notre projet aussi ! Chaque équipe a dû faire un pitch le samedi soir pour présenter l'avancement du projet, mais pour conserver le Wow Effect nous avons évité de tout dévoiler ... :) Comme le développement de l'application Windows Phone se terminait tout doucement, nous avons décidé de développer une application en plus, pour Windows 8 cette fois ! Le dimanche soir, nous avons préparé le dernier pitch qui devait présenter l'ensemble de notre travail. La démo s'est très bien passée, et nous avons pu en live dévoiler l'application  Windows 8 qui a eu son petit succès ! :)

Présentation de HowTo le dimanche soir / credit photo : BeMyApp Belgique

Nous étions déjà assez fiers du résultat, mais plus encore après les présentations, lorsque nous avons eu les premiers retours des autres participants. Ce projet qui au départ n'avait pas tellement enthousiasmé les experts présents lors du premier pitch a finalement surpris tout le monde et convaincu un grand nombre de son potentiel. C'est en cela que l'on apprécie d'avoir des graphistes sur un projet. Ce que nous avons pu présenter à la fin du weekend donnait l'impression d'un produit fini ! Les jurys devaient évaluer les applications sur 4 critères : l’innovation et l’originalité ; la réalisation, de l’idée à l’application ; le potentiel business ; la scalability. Après délibération, nous avons été retenus pour la 3ème position ! La compétition a ensuite continué pour l'équipe FirstSight, désignée vainqueur à l'ICAB et qui a donc représenté la Belgique pour la BeMyApp WorldCup. Malheureusement, les résultats viennent de tomber et FirstSight n'a pas remporté la coupe ...

L'équipe HowTo ! / credit photo : Gregory Vandevyver

Au final, ce weekend a été une expérience idéale pour nous rebooster et nous rappeler ce qu'il est possible de réaliser à partir d'une simple idée [à faire évoluer], et tout cela en à peine 48 heures ! Si ce genre d'activité vous fait envie, n'hésitez pas à l'exprimer ! :) Il n'est pas impossible d'organiser de tels événements en Wallonie... Je remercie encore une fois toute l'équipe avec laquelle j'ai eu la chance de passer ce moment. Si c'est à refaire, comptez sur moi ! Composition de la team HowTo : Anne Laure de Harlez : Porteuse de projet Marine Visart : Graphiste Martin Caezza : Graphiste Piter-Jan : Développeur Java/Android Stéphane Vidouse : Développeur .NET Julien Lebutte : Développeur .NET Kévin Rapaille : Développeur .NET Renaud Dumont : Développeur .NET


Par Renaud Dumont, IT Evangelist au Microsoft Innovation Center

Windows Phone Summit meetup at MIC - 20th June 2012

7. June 2012 15:39 by Renaud in   //  Tags:   //   Comments (0)

As you may know, the 20th June is a very important day ! This is the day of the Windows Phone Summit event, happening in San Francisco. This is a conference about the futur of Windows Phone, and we can expect some awesome news !

That's why I'm very happy to invite you to spend your evening at the Microsoft Innovation Center, in Mons ! We could watch the event all together, share our first impressions, talk about mobile technologies and share our experiences on the Windows Phone platform. Of course that night wouldn't be a success without some beer and a few pizzas !

Registrations are open and free : http://events.mic-belgique.be/event/windows-phone-summit-live-mic-belgique

Save the date and join us to discover what the future of Windows Phone will be made of !

Windows Phone Summit meetup au MIC - 20 juin 2012

7. June 2012 14:06 by Renaud in   //  Tags:   //   Comments (0)

Comme vous le savez peut-être, le 20 juin prochain est une date importante ! C’est ce jour-là qu’aura lieu le Windows Phone Summit : il s’agit d’une conférence parlant de l’avenir de la plateforme Windows Phone, avec de très belles annonces en perspective !

C’est pourquoi j’ai le plaisir de vous inviter à venir passer la soirée au MIC pour suivre l’événement en direct sur grand écran et partager vos impressions avec d’autres développeurs. On pourra parler technologies mobiles sans langue de bois, s’échanger nos expériences et nos applications WP7… tout en buvant un verre et en grignotant des pizzas dans une ambiance sympathique !

L'inscription est gratuite et se fait via ce lienhttp://events.mic-belgique.be/event/windows-phone-summit-live-mic-belgique

Venez nous rejoindre pour découvrir ensemble de quoi le futur de Windows Phone sera fait !

Kinect SDK 1.5 - Face tracking in C#

1. June 2012 20:06 by Renaud in   //  Tags:   //   Comments (23)

 

The SDK 1.5 has been released and with it come a lot of new features such as the very nice face tracking toolkit : Microsoft.Kinect.Toolkit.FaceTracking !

The idea is awesome and will probably open the door to a lot of new ways of using the Kinect ! It makes it easy to animate a 3D face model, and the result is quite awesome !

I wanted to test it by myself and see what I could do with my amazing artistic skills. I'll show you what I did and how !

 

This is a drawing made with a few shapes in a WPF application. We will use the face tracking functionality to animate it ! In this application, we will use only a few of the information we can get from the Kinect, but the aim is to show how easy it is, and how it works.

You can download the full project right here and play with it : http://sdrv.ms/KMjNMQ


Install the resources

For implementing face tracking, we need the SDK 1.5 and the toolbox. You can download both of them on the Kinect for Windows website : http://www.microsoft.com/en-us/kinectforwindows/develop/developer-downloads.aspx.

When it is installed, you can see that line in the config panel :

The Toolkit will install Kinect Studio, a few projects samples in C#/VB.Net/C++, and two libraries for face tracking ( compiled in 32 and 64 bits) :

  • FaceTrackData.dll
  • FaceTrackLib.dll

Everything stands in the same folder as the SDK : 

If you develop a C++ application, you can directly use the face tracking libraries in your project. In the other case, you should use a wrapper that exposes the libraries in managed code.

By chance, the Developer Toolkit gives you a project sample that you can use to start directly ! Launch the "Developer Toolkit Browser", and goes under the Components menu. Then, you'll find two projects :

  • Microsoft.Kinect.Toolkit
  • Microsoft.Kinect.Toolkit.FaceTracking

You can install them somewhere on your hard drive, so that you have a copy that you can reuse in your own projects.

Create a new WPF/C# project

To be able to use the Face Tracking capabilities in my new project modestly called AwesomeFaceTracking, I have to include the Microsoft.Kinect.Toolkit.FaceTracking sample project in the solution, and then add it as a reference to my project.

It is also necessary to add to your project the two face tracking libraries installed with the SDK ! We can find them by default in the folder : C:Program FilesMicrosoft SDKsKinectDeveloper Toolkit v1.5.0Redist. Those .dll files must be placed in the same folder as the executable application.

You need those libraries because the wrapper project will use them !

Then we will also add a reference to the Microsoft.Kinect assembly, and finally we can add those two namespaces to the MainWindows class :

using Microsoft.Kinect;
using Microsoft.Kinect.Toolkit.FaceTracking;

Initialize the KinectSensor and the FaceTracker

To increase our chances to detect a face, we will use all the possibilities of the Kinect ! In the application, once a KinectSensor is found, we will enable all the different streams : ColorImageStream, DepthImageStream and SkeletonStream.

                // Initialize all the necessary streams:
                // - ColorStream with default format
                // - DepthStream with Near mode and lowest resolution
                // - SkeletonStream with tracking in NearReange and Seated mode.

                kinectSensor.ColorStream.Enable();

                kinectSensor.DepthStream.Range = DepthRange.Near;
                kinectSensor.DepthStream.Enable(DepthImageFormat.Resolution80x60Fps30);

                kinectSensor.SkeletonStream.EnableTrackingInNearRange = true;
                kinectSensor.SkeletonStream.TrackingMode = SkeletonTrackingMode.Seated;
                kinectSensor.SkeletonStream.Enable(
                    new TransformSmoothParameters() {
                        Correction = 0.5f, 
                        JitterRadius = 0.05f, 
                        MaxDeviationRadius = 0.05f, 
                        Prediction = 0.5f, 
                        Smoothing = 0.5f 
                    });

                // Listen to the AllFramesReady event to receive KinectSensor's data.
                kinectSensor.AllFramesReady += new EventHandler<AllFramesReadyEventArgs>(kinectSensor_AllFramesReady);

                // Initialize data arrays
                colorPixelData = new byte[kinectSensor.ColorStream.FramePixelDataLength];
                depthPixelData = new short[kinectSensor.DepthStream.FramePixelDataLength];
                skeletonData = new Skeleton[6];

                // Starts the Sensor
                kinectSensor.Start();

                // Initialize a new FaceTracker with the KinectSensor
                faceTracker = new FaceTracker(kinectSensor);

I suppose you know what those lines are for. The only novelty here is the last one initializing a FaceTracker object. We also use the lowest resolution for the DepthImageStream as it gives a smoother result.

All the job will happen in the eventhandler of the AllFramesReady event !

        void kinectSensor_AllFramesReady(object sender, AllFramesReadyEventArgs e)
        {
            // The code extracts below must be added here ;)
        }

Get a face frame

In the toolkit, the object that represents the face is FaceTrackFrame. To get one, we will use the Track method of the FaceTracker object by giving him all the data we can get from the Kinect. The FaceTracker object will the process all that data and try to find a face in it !

We first retrieve the data from all the different frames. To be sure the data is synchronized, we will only reach the end of the process if all of the streams give us a frame AND that a tracked skeleton has been found !

            using (ColorImageFrame colorImageFrame = e.OpenColorImageFrame())
            {
                if (colorImageFrame == null)
                    return;
                colorImageFrame.CopyPixelDataTo(colorPixelData);
            }

            using (DepthImageFrame depthImageFrame = e.OpenDepthImageFrame())
            {
                if (depthImageFrame == null)
                    return;
                depthImageFrame.CopyPixelDataTo(depthPixelData);
            }

            using (SkeletonFrame skeletonFrame = e.OpenSkeletonFrame())
            {
                if (skeletonFrame == null)
                    return;
                skeletonFrame.CopySkeletonDataTo(skeletonData);
            }

            var skeleton = skeletonData.FirstOrDefault(s => s.TrackingState == SkeletonTrackingState.Tracked);
            if (skeleton == null)
                return;

If we are here at the execution time, it means that we have enough data to expect detecting a face !

We will then use the FaceTracker and provide him the image, the depth data, and the tracked skeleton for which we would like to detect the face.

            FaceTrackFrame faceFrame = faceTracker.Track(kinectSensor.ColorStream.Format, colorPixelData,
                                              kinectSensor.DepthStream.Format, depthPixelData,
                                              skeleton);

In the faceFrame variable, you'll get an object of type FaceTrackFrame, which represents the tracked face. For a fully detailed description, have a look at this post on MSDN : http://msdn.microsoft.com/en-us/library/jj130970. Here are the basics :

First of all, TrackSuccessful is a boolean that tells you whether the face has been detected or not ! FaceRect is the rectangle zone in which the face stands.

But the most important is certainly the methods: they allow you to get up to 87 points representing the face. Those points can be retrieved in a 2-dimensional or a 3-dimensional space. You can also retrieve a few more information about the facial expressions of the user !

Get3DShape() returns a collection of 87 points in 3D.

GetProjected3DShape() returns the same collection but in a 2D referential corresponding to a 640x480 pixels image.

GetAnimationUnitCoefficients() returns the values describing the facial expressions. That's what we are going to use in the next part of this project.  For more information on this, you can read : Animation Units on MSDN.

GetTriangles() is a method that you can use in association with the Get3DShape method. It will return you a collection of triangles, and for each triangles 3 indices corresponding that indicates which points in the collection returned by Get3DShape are vertices of the triangle. For those of you who are used to work with 3D modeling, it will be helpful to create an draw an animated model of the whole face !

Simple face drawing

In this part, we will just write a few lines of XAML to draw something that looks like a human face. We will also add some Transformations (Translations, Rotations, Scales, ...) that will be used with the Animation Units coeff to animate the drawing.

The RenderTransform objects allows you to change the rendering of a visual UI element after it has been created. Look for example at the Ellipse which stands for the mouth (Ellipse with x:Name="Mouth") : it has a ScaleTransform object that can be scaled over the X or Y axis. We will use it to mimic the opening of the mouth.

<Window x:Class="AwesomeFaceTracking.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525">
    <Grid>
        <Grid>
            <Canvas x:Name="MainCanvas" Width="500" Height="500">
                <Canvas.RenderTransform>
                    <TransformGroup>
                        <RotateTransform x:Name="CanvasRotate" CenterX="250" CenterY="250" />
                    </TransformGroup>
                </Canvas.RenderTransform>
                <Ellipse Width="300" Height="300" x:Name="Face"  StrokeThickness="2" Stroke="Black" Canvas.Left="105" Canvas.Top="6" />
                <Ellipse Width="30" Height="30" x:Name="LeftEye" Stroke="Black" StrokeThickness="2" Canvas.Left="289" Canvas.Top="102" />
                <Ellipse Canvas.Left="194" Canvas.Top="102" x:Name="RightEye" Height="30" Stroke="Black" StrokeThickness="2" Width="30" />
                <Ellipse Canvas.Left="224" Canvas.Top="239" Height="18" x:Name="Mouth" Stroke="Black" StrokeThickness="2" Width="64" >
                    <Ellipse.RenderTransform>
                        <ScaleTransform x:Name="MouthScaleTransform" CenterX="32" CenterY="9" ScaleX="1" ScaleY="1"/>
                    </Ellipse.RenderTransform>
                </Ellipse>

                <Rectangle Width="70" Stroke="Black" Fill="Black" StrokeThickness="10" Height="5" Canvas.Left="169" Canvas.Top="80">
                    <Rectangle.RenderTransform>
                        <TransformGroup>
                            <TranslateTransform x:Name="RightBrow" />
                            <RotateTransform x:Name="RightBrowRotate" CenterX="50" Angle="0" />
                        </TransformGroup>
                    </Rectangle.RenderTransform>
                </Rectangle>

                <Rectangle  Width="70" Stroke="Black" Fill="Black" StrokeThickness="10" Height="5" Canvas.Left="274" Canvas.Top="80" >
                    <Rectangle.RenderTransform>
                        <TransformGroup>
                            <TranslateTransform x:Name="LeftBrow" />
                            <RotateTransform x:Name="LeftBrowRotate" CenterX="20" Angle="0" />
                        </TransformGroup>
                    </Rectangle.RenderTransform>
                </Rectangle>
                <Rectangle Canvas.Left="207" Canvas.Top="148" Fill="Black" Height="5" Stroke="Black" StrokeThickness="10" Width="50">
                    <Rectangle.RenderTransform>
                        <TransformGroup>
                            <RotateTransform Angle="-70" CenterX="50" />
                        </TransformGroup>
                    </Rectangle.RenderTransform>
                </Rectangle>
                <Rectangle Canvas.Left="246" Canvas.Top="190" Fill="Black" Height="5" Stroke="Black" StrokeThickness="10" Width="15">
                    <Rectangle.RenderTransform>
                        <TransformGroup>
                            <RotateTransform Angle="0" CenterX="50" />
                        </TransformGroup>
                    </Rectangle.RenderTransform>
                </Rectangle>
            </Canvas>
        </Grid>
    </Grid>
</Window>

Consume the frame

We will first the check that the tracking succeeded. If it did, we will retrieve the Animation Units coefficients. Those values will tell us whether the tracked face has an opened or closed mouth or it is smiling, whether its brows are raised or not, and so on...

                if (faceFrame.TrackSuccessful)
                {
                    // Gets the AU coeffs
                    var AUCoeff = faceFrame.GetAnimationUnitCoefficients();

                    // -1 <= x <= 0  => mouth is closed
                    // 0 < x < 1 => mouth is opening
                    // x == 1 => mouth is fully opened
                    var jawLowerer = AUCoeff[AnimationUnit.JawLower];
                    jawLowerer = jawLowerer < 0 ? 0 : jawLowerer;
                    MouthScaleTransform.ScaleY = jawLowerer * 5 + 0.1;
                    MouthScaleTransform.ScaleX = (AUCoeff[AnimationUnit.LipStretcher] + 1);

                    // Brows raising
                    LeftBrow.Y = RightBrow.Y = (AUCoeff[AnimationUnit.BrowLower]) * 40;

                    // brows angle
                    RightBrowRotate.Angle = (AUCoeff[AnimationUnit.BrowRaiser] * 20);
                    LeftBrowRotate.Angle = -RightBrowRotate.Angle;

                    // Face angle on the Z axis
                    CanvasRotate.Angle = faceFrame.Rotation.Z;
                }

In the above code, we adapt the values to create a nice animation because all of the coefficients values are within the range of -1 and 1.


That's all for face tracking ! You can see that it is really easy to use, and the tracking seems precise and smooth.

We could regret that - despite the fact that it is a recurrent request from developers - there is still no hand tracking API, but Face Tracking is already a great improvement and seeing how fast the Kinect Team delivered that release, maybe we could expect a good surprise for the next version. However, nothing has been announced in that direction. Wait and see!

Kinect SDK 1.5 - Le FaceTracking en C#

1. June 2012 15:45 by Renaud in   //  Tags:   //   Comments (3)

 Avec la sortir du SDK 1.5, on a droit à quelques nouveautés bien sympathiques, dont le très appréciable toolkit de détection faciale : Microsoft.Kinect.Toolkit.FaceTracking !

L'idée est excellente et pourra certainement apporter de nouvelles utilisations intéressantes de la Kinect !

J'ai voulu moi aussi tester cette API et voir ce que je pouvais en tirer en combinant mes talents d'artistes à mes compétences en programmation... Le résultat est bluffant ! :D Je vous montre !

 

Ce visage a été grossièrement dessiné à partir de quelques formes en WPF, et on va utiliser la fonctionnalité de détection faciale pour l'animer ! Dans cette application, on n'utilisera qu'une petite partie des informations que l'on peut obtenir grâce à la Kinect, mais l'intérêt est surtout de montrer comment tout cela fonctionne !

Vous pouvez télécharger le projet ici pour tester par vous même : http://sdrv.ms/KMjNMQ


Installation des ressources

Pour pouvoir utiliser la détection faciale, il faut d'abord installer le SDK 1.5 ainsi que la boîte à outils (Kinect for Windows Developer Toolkit). Le tout est téléchargeable sur le site de référence:

http://www.microsoft.com/en-us/kinectforwindows/develop/developer-downloads.aspx.

Une fois installé, vous pourrez retrouver cette ligne dans le panneau de configuration:

Le Toolkit installera notamment Kinect Studio, une flopée de projets d'exemples en C#/VB.Net/C++, et deux librairies pour la détection faciale (compilées en 32 et 64 bits) :

  • FaceTrackData.dll
  • FaceTrackLib.dll

Le tout se trouve dans le même dossier d'installation que le SDK : 

Si vous développez une application C++, vous pouvez directement utiliser les deux librairies citées ci-dessus. Dans le cas contraire, il faudra utilisé un wrapper pour exposer ces librairies en code managé.

Par chance, pour pouvoir commencer rapidement, le Developer Toolkit en propose également un ! Lancez le "Developer Toolkit Browser", et allez dans la rubrique Components. Là, vous trouverez deux projets :

  • Microsoft.Kinect.Toolkit
  • Microsoft.Kinect.Toolkit.FaceTracking

Vous pouvez les installer quelque part sur votre disque pour en avoir une copie.

Création d'un nouveau projet WPF/C#

Pour utiliser la détection faciale dans mon nouveau projet modestement appelé AwesomeFaceTracking, il faut inclure le projet Microsoft.Kinect.Toolkit.FaceTracking dans la solution et ensuite l'ajouter en référence au projet AwesomeFaceTracking.

Il est également nécessaire d'ajouter au projet les deux librairies de tracking installées avec le SDK. On les retrouve par défaut dans ce dossier: C:Program FilesMicrosoft SDKsKinectDeveloper Toolkit v1.5.0Redist . 

Vous avez besoin de ces librairies parce que le projet du Toolkit précédemment ajouté à votre solution n'est qu'un Wrapper, ce qui signifie qu'il va servir d'adaptateur et permettre d'utiliser les fonctionnalités des librairies non-managées directement dans notre application .NET.

On va également ajouter une référence à la librairie Microsoft.Kinect, et on peut finalement ajouter les espaces de noms nécessaires dans la classe MainWindow :

using Microsoft.Kinect;
using Microsoft.Kinect.Toolkit.FaceTracking;

Initialisation du KinectSensor et du FaceTracker

Pour augmenter nos chances de détecter un visage, on ne va pas hésiter et on a va utiliser toutes les capacités de la Kinect ! Dans l'application, une fois qu'on a récupéré un objet Kinect, on va donc activer les différents flux: ColorImageStream, DepthImageStream et SkeletonStream.

                // Initialize all the necessary streams:
                // - ColorStream with default format
                // - DepthStream with Near mode and lowest resolution
                // - SkeletonStream with tracking in NearReange and Seated mode.

                kinectSensor.ColorStream.Enable();

                kinectSensor.DepthStream.Range = DepthRange.Near;
                kinectSensor.DepthStream.Enable(DepthImageFormat.Resolution80x60Fps30);

                kinectSensor.SkeletonStream.EnableTrackingInNearRange = true;
                kinectSensor.SkeletonStream.TrackingMode = SkeletonTrackingMode.Seated;
                kinectSensor.SkeletonStream.Enable(
                    new TransformSmoothParameters() {
                        Correction = 0.5f, 
                        JitterRadius = 0.05f, 
                        MaxDeviationRadius = 0.05f, 
                        Prediction = 0.5f, 
                        Smoothing = 0.5f 
                    });

                // Listen to the AllFramesReady event to receive KinectSensor's data.
                kinectSensor.AllFramesReady += new EventHandler<AllFramesReadyEventArgs>(kinectSensor_AllFramesReady);

                // Initialize data arrays
                colorPixelData = new byte[kinectSensor.ColorStream.FramePixelDataLength];
                depthPixelData = new short[kinectSensor.DepthStream.FramePixelDataLength];
                skeletonData = new Skeleton[6];

                // Starts the Sensor
                kinectSensor.Start();

                // Initialize a new FaceTracker with the KinectSensor
                faceTracker = new FaceTracker(kinectSensor);

J'imagine que vous savez à quoi servent toutes ces lignes. La seule nouveauté ici est la dernière qui initialise l'objet FaceTracker. Aussi, j'utilise la plus petite résolution pour le DepthImageStream. La détection fonctionne aussi et il semble que le traitement des données mette beaucoup moins de temps (avec la résolution par défaut, le résultat est saccadé).

Tout va se passer maintenant dans l'eventhandler de l'événement AllFramesReady !

        void kinectSensor_AllFramesReady(object sender, AllFramesReadyEventArgs e)
        {
            // Tout le code qui suit est à introduire ici ;)
        }

Obtenir une représentation du visage

Dans le toolkit, l'objet représentant une photographie du visage est de type FaceTrackFrame. Pour l'obtenir on va utiliser la méthode Track de la classe FaceTracker en lui passant toutes les données dont on dispose et qui seront utilisées par le tracker pour détecter le visage.

On commence par récupérer les données de chacune des frames. Pour que les données soient concordantes, on ne va au bout de processus que si on a bien reçu des données de chaque flux.

Enfin, on cherche le premier objet Skeleton représentant une personne détectée par la Kinect.

            using (ColorImageFrame colorImageFrame = e.OpenColorImageFrame())
            {
                if (colorImageFrame == null)
                    return;
                colorImageFrame.CopyPixelDataTo(colorPixelData);
            }

            using (DepthImageFrame depthImageFrame = e.OpenDepthImageFrame())
            {
                if (depthImageFrame == null)
                    return;
                depthImageFrame.CopyPixelDataTo(depthPixelData);
            }

            using (SkeletonFrame skeletonFrame = e.OpenSkeletonFrame())
            {
                if (skeletonFrame == null)
                    return;
                skeletonFrame.CopySkeletonDataTo(skeletonData);
            }

            var skeleton = skeletonData.FirstOrDefault(s => s.TrackingState == SkeletonTrackingState.Tracked);
            if (skeleton == null)
                return;

Si on arrive à cet endroit du code durant l'exécution, c'est qu'on a toutes les données nécessaires pour pouvoir espérer détecter un visage !

On va donc faire appel au FaceTracker en lui donnant comme infos: l'image, la profondeur, leurs formats respectifs, et le skeleton suivi pour lequel on aimerait détecter le visage.

            FaceTrackFrame faceFrame = faceTracker.Track(kinectSensor.ColorStream.Format, colorPixelData,
                                              kinectSensor.DepthStream.Format, depthPixelData,
                                              skeleton);

La variable faceFrame va contenir un objet de type FaceTrackFrame, qui représente l'état d'un visage à un instant T. Pour avoir une description détaillée, vous pouvez lire la doc MSDN : http://msdn.microsoft.com/en-us/library/jj130970. Voici toutefois en substance ce qu'il faut savoir:

Tout d'abord, TrackSuccessful est un booléen indiquant si un visage a pu être détecté ! FaceRect contient la zone dans laquelle se trouve le visage.

Mais ce sont surtout les méthodes qui nous intéressent ! Il est possible d'obtenir les positions de 87 points représentants le visage, soit dans un espace en deux ou trois dimensions, ainsi que des informations supplémentaires sur les expressions du visage !

Get3DShape() retourne une collection de points en 3D.

GetProjected3DShape() retourne la même collection mais dans un espace 2D correspondant à une image de 640x480 pixels.

GetAnimationUnitCoefficients() retourne des valeurs spécifiques décrivant la déformation d'une partie du visage par rapport à sa position initiale. C'est ce qu'on va utiliser dans la suite de ce projet ;) Je vous invite encore une fois à lire la partie consacrée aix Animation Units sur MSDN.

GetTriangles() est à utiliser en association avec Get3DShape puisqu'elle retourne une collection de triangles décrits par des index des points de ce triangle dans la collection retournée par Get3DShape. Pour ceux qui ont l'habitude de travailler avec des objets 3D, on va ainsi pouvoir créer facilement des vertices et animer un modèle du visage tout entier !

Dessin simplifié du visage

Dans cette partie, on va simplement ajouter un peu de code dans la partie XAML de MainWindows pour y afficher quelque chose ressemblant à un visage. Pour pouvoir l'animer par la suite à partir des coefficients AU, on utilise des Transformations : Translations, Rotation, Étirement, etc...

Les RenderTransform permettent de modifier le rendu graphique d'un élément visuel après qu'il ait été créé. Remarquez par exemple la bouche (Ellipse appelée Mouth) : elle est accompagné d'un ScaleTransform qui permet de modifier l'échelle de l'axe des X ou des Y. On va l'utiliser pour reproduire les mouvements de la bouche qui s'ouvre et se ferme !

<Window x:Class="AwesomeFaceTracking.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525">
    <Grid>
        <Grid>
            <Canvas x:Name="MainCanvas" Width="500" Height="500">
                <Canvas.RenderTransform>
                    <TransformGroup>
                        <RotateTransform x:Name="CanvasRotate" CenterX="250" CenterY="250" />
                    </TransformGroup>
                </Canvas.RenderTransform>
                <Ellipse Width="300" Height="300" x:Name="Face"  StrokeThickness="2" Stroke="Black" Canvas.Left="105" Canvas.Top="6" />
                <Ellipse Width="30" Height="30" x:Name="LeftEye" Stroke="Black" StrokeThickness="2" Canvas.Left="289" Canvas.Top="102" />
                <Ellipse Canvas.Left="194" Canvas.Top="102" x:Name="RightEye" Height="30" Stroke="Black" StrokeThickness="2" Width="30" />
                <Ellipse Canvas.Left="224" Canvas.Top="239" Height="18" x:Name="Mouth" Stroke="Black" StrokeThickness="2" Width="64" >
                    <Ellipse.RenderTransform>
                        <ScaleTransform x:Name="MouthScaleTransform" CenterX="32" CenterY="9" ScaleX="1" ScaleY="1"/>
                    </Ellipse.RenderTransform>
                </Ellipse>

                <Rectangle Width="70" Stroke="Black" Fill="Black" StrokeThickness="10" Height="5" Canvas.Left="169" Canvas.Top="80">
                    <Rectangle.RenderTransform>
                        <TransformGroup>
                            <TranslateTransform x:Name="RightBrow" />
                            <RotateTransform x:Name="RightBrowRotate" CenterX="50" Angle="0" />
                        </TransformGroup>
                    </Rectangle.RenderTransform>
                </Rectangle>

                <Rectangle  Width="70" Stroke="Black" Fill="Black" StrokeThickness="10" Height="5" Canvas.Left="274" Canvas.Top="80" >
                    <Rectangle.RenderTransform>
                        <TransformGroup>
                            <TranslateTransform x:Name="LeftBrow" />
                            <RotateTransform x:Name="LeftBrowRotate" CenterX="20" Angle="0" />
                        </TransformGroup>
                    </Rectangle.RenderTransform>
                </Rectangle>
                <Rectangle Canvas.Left="207" Canvas.Top="148" Fill="Black" Height="5" Stroke="Black" StrokeThickness="10" Width="50">
                    <Rectangle.RenderTransform>
                        <TransformGroup>
                            <RotateTransform Angle="-70" CenterX="50" />
                        </TransformGroup>
                    </Rectangle.RenderTransform>
                </Rectangle>
                <Rectangle Canvas.Left="246" Canvas.Top="190" Fill="Black" Height="5" Stroke="Black" StrokeThickness="10" Width="15">
                    <Rectangle.RenderTransform>
                        <TransformGroup>
                            <RotateTransform Angle="0" CenterX="50" />
                        </TransformGroup>
                    </Rectangle.RenderTransform>
                </Rectangle>
            </Canvas>
        </Grid>
    </Grid>
</Window>

Consommer la frame !

On va donc commencer par vérifier que la détection a correctement fonctionné. Si c'est le cas, on récupère les Animation Units. Ces données vont ainsi indiquer si la personne trackée ouvre ou ferme la bouche, hausse ou fronce les sourcils, fait un sourire ou a la bouche droite.

                if (faceFrame.TrackSuccessful)
                {
                    // Récupération des coefficients AU
                    var AUCoeff = faceFrame.GetAnimationUnitCoefficients();

                    // -1 <= x <= 0  => bouche fermée
                    // 0 < x < 1 => bouche entrouverte
                    // x == 1 => bouche entièrement ouverte
                    var jawLowerer = AUCoeff[AnimationUnit.JawLower];
                    jawLowerer = jawLowerer < 0 ? 0 : jawLowerer;
                    MouthScaleTransform.ScaleY = jawLowerer * 5 + 0.1;
                    MouthScaleTransform.ScaleX = (AUCoeff[AnimationUnit.LipStretcher] + 1);

                    // Élévation des sourcils
                    LeftBrow.Y = RightBrow.Y = (AUCoeff[AnimationUnit.BrowLower]) * 40;

                    // Ínclinaison des sourcils
                    RightBrowRotate.Angle = (AUCoeff[AnimationUnit.BrowRaiser] * 20);
                    LeftBrowRotate.Angle = -RightBrowRotate.Angle;

                    // Inclinaison du visage par rapport à l'axe Z
                    CanvasRotate.Angle = faceFrame.Rotation.Z;
                }

Dans cet exemple de code, on adapte un petit peu les coefficients pour donner un rendu sympathique à l'animation parce que tous les coefficients sont des valeurs comprises entre - 1 et 1.


Voilà donc pour la détection du visage ! On notera la simplicité d'utilisation. Il suffit de donner les bonnes informations à l'objet de détection faciale pour qu'il fasse tout le boulot. Cela montre bien l'intérêt de la Kinect et de la quantité importante de données qu'elle peut fournir ! En temps normal, la détection aurait dû se faire uniquement sur base des couleurs, mais ici on peut en plus utiliser les distances et la position du squelette pour cadrer et détecter les différentes parties du visage.

Concernant la détection des mains et des doigts maintenant - et même s'il est vrai que c'est une demande récurrente des développeurs - il n'y a toujours pas d'API dans le SDK Kinect. Étant donné la vitesse avec laquelle la release 1.5 a été publiée, on peut peut-être espérer une bonne surprise pour la prochaine version. Mais rien n'a été suggéré dans ce sens pour le moment.

TextBox

About the author

I'm a developer, blog writer, and author, mainly focused on Microsoft technologies (but not only Smile). I'm Microsoft MVP Client Development since July 2013.

Microsoft Certified Professional

I'm currently working as an IT Evangelist with an awesome team at the Microsoft Innovation Center Belgique, where I spend time and energy helping people to develop their projects. I also give training to enthusiastic developers and organize afterworks with the help of the Belgian community.

MIC Belgique

Take a look at my first book (french only): Développez en HTML 5 pour Windows 8

Développez en HTML5 pour Windows 8

Membre de l'association Fier d'être développeur

TextBox

Month List