Rapport de fonctionnement Kinect 2 - Kevin Marburger · 2015. 6. 12. · Capture avec Kinect 2 Caractéristiques de la Kinect Présentation de la Kinect La Kinect pour Windows est

Rapport Fonctionnement Kinect

Capture avec Kinect 2

Sommaire Rapport Fonctionnement Kinect 1 Sommaire 2 Introduction 3

Présentation du Projet 3 Notre Projet 3 Matériel à disposition 3

Caractéristiques de la Kinect 4 Présentation de la Kinect 4

Initialiser la Kinect 6 Détection du corps avec Kinect 9

Généralités 9 Détection de la profondeur 10 Récupérer les distances à partir du tableau d’octets 11 Construire une Depth Map (image de profondeur) 13 Utilisation du PlayerIndex 14 La récupération du squelette 17 Traitement des informations du squelette 19

Détection du visage avec Kinect 23 Tutoriel 23 Fonctions et classes importantes 25 Visuels 26

Détection du son avec la Kinect 27 Généralités 27 Choisir le bon environnement 31

Compatibilité avec Unity Pro 32 Bibliographie / Annexes 33

V. Le Mellay - A. Paillard - K. Marburger Page � sur �2 33


Introduction

Présentation du Projet Le projet s’inscrit dans un plan global en partenariat avec différents acteurs : IIM, Strate College Design, l’artiste Florent Aziosmanoff (initiateur du projet) ainsi que le Louvre (possible).

Le projet sera présenté à Futur en Seine 2015, il devra démontrer toutes les capacités que nous pouvons mettre en place pour réaliser un projet d’envergure et par la même occasion, faire la « promotion » de l’école.

Le projet sera multisupports (tablette, Web, smartphone …), avec à chaque fois un contenu adapter pour proposer une expérience différente.

La Joconde interactive possédera une intelligence artificielle capable de réagir en fonction du public et des émotions qu’ils dégages. Exemple : une personne s’approche, Mona Lisa fait un clin d’oeil, ou montre de la réticence (recul du visage).

Cependant toutes ces actions ne doivent pas dénaturer le tableau et tous les mouvements doivent rester très subjectifs. Le niveau de qualité devra être comparable à cette vidéo : B E A U T Y - dir. Rino Stefano Tagliafierro (cliquer sur le lien pour voir la vidéo)

Notre Projet Pour qu’une interaction intéressante puisse exister avec le public, nous devrons exploiter au maximum toutes capacités de détection de la caméra (émotions, mouvements, dialogues? …) et en rédiger un rapport pour démontrer ce qui est possible ou non, nous devrons êtres capables d’identifier les informations transmises entre le pc de gestion et la Kinect.

Matériel à disposition - Caméra Kinect - Ecran 4K - Tablette - Pc de traitement - Salle de travail (E311)


http://vimeo.com/83910533


Caractéristiques de la Kinect Présentation de la KinectLa Kinect pour Windows est polyvalente. Elle permet la détection du corps (jusqu’à 6 personnes peuvent être suivis en même temps), les mains (ouvertes ou fermées) ainsi que le visage. Le capteur Kinect pour Windows a une caméra RVB (rouge-vert-bleu) pour la vidéo couleur, un émetteur infrarouge et une caméra qui mesure la profondeur.

→ Caméra couleur 1080p tournant à 30fps

→ Une caméra infrarouge 512x484, et un émetteur de lumière infrarouge

→ Détection du corps (25 articulations par personne), maximum 6 personnes

→ Détection du visage

→ 4 microphones hautes performances

Matériel requis :

→ Processeur 64 bits (x64), dual-core 3.1 GHz (ou plus)

→ Port USB 3.0

→ Au moins 2 Gb de RAM

→ Carte graphique supportant DirectX 11

→ Windows 8 ou 8.1



Le capteur Kinect pour Windows permet une grande variété d'interactions, cependant les contraintes techniques imposent une limitation de détection qui défini ses priorités et limites comme suit :



Initialiser la Kinect La première étape pour créer une application Kinect est de créer l’interface utilisateur (UI). Pour cela, on utilise les fichiers XAML(Extensible Application Markup Language). Le XAML est un langage propre à Windows se rapprochant de l’XML.

Dans le SDK de la Kinect V2, chaque programme a son code, accessible. Avec le plus souvent un fichier nommé MainPage.xaml. Ce fichier est la “mise en page” de l’application.

<Page x:Class="KinectMinimalFaceTrackingDemo.MainPage" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" DataContext="{Binding RelativeSource={RelativeSource Self}}" mc:Ignorable="d">

<Page.Resources> <Style x:Name="RedTB" TargetType="TextBlock"> <Setter Property="FontSize" Value="40"/> <Setter Property="Foreground" Value="Crimson"/> <Setter Property="HorizontalAlignment" Value="Right"/> <Setter Property="VerticalAlignment" Value="Center"/> <Setter Property="Margin" Value="5"/> <Setter Property="Grid.Column" Value="0"/> </Style>

<Style x:Name="VioletTB" TargetType="TextBlock"> <Setter Property="FontSize" Value="40"/> <Setter Property="Foreground" Value="BlueViolet"/> <Setter Property="HorizontalAlignment" Value="Left"/> <Setter Property="VerticalAlignment" Value="Center"/> <Setter Property="Margin" Value="5"/> <Setter Property="Grid.Column" Value="1"/> </Style> </Page.Resources> <Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}"> <Grid.RowDefinitions> <RowDefinition Height="90"/> <RowDefinition Height="90"/> <RowDefinition Height="90"/> <RowDefinition Height="90"/> <RowDefinition Height="90"/> <RowDefinition Height="90"/> <RowDefinition Height="90"/> <RowDefinition Height="90"/> </Grid.RowDefinitions> <Grid.ColumnDefinitions> <ColumnDefinition Width="350"/> <ColumnDefinition Width="750"/> </Grid.ColumnDefinitions>



Exemple de fichier xaml pour la détection du visage

<TextBlock Style="{StaticResource RedTB}" Grid.Row="1" Text="Kinect Status"/> <TextBlock Style="{StaticResource RedTB}" Grid.Row="2" Text="Tracking Body"/> <TextBlock Style="{StaticResource RedTB}" Grid.Row="3" Text="Tracking Face"/> <TextBlock Style="{StaticResource RedTB}" Grid.Row="4" Text="Body Frame Count"/> <TextBlock Style="{StaticResource RedTB}" Grid.Row="5" Text="Face Frame Count"/> <TextBlock Style="{StaticResource RedTB}" Grid.Row="6" Text="Right Hand"/> <TextBlock Style="{StaticResource RedTB}" Grid.Row="7" Text="Face Engaged"/>

<TextBlock Style="{StaticResource VioletTB}" Grid.Row="1" Text="{Binding KinectStatus}"/> <TextBlock Style="{StaticResource VioletTB}" Grid.Row="2" Text="{Binding TrackingBody}"/> <TextBlock Style="{StaticResource VioletTB}" Grid.Row="3" Text="{Binding TrackingFace}"/> <TextBlock Style="{StaticResource VioletTB}" Grid.Row="4" Text="{Binding BodyFrameCount}"/> <TextBlock Style="{StaticResource VioletTB}" Grid.Row="5" Text="{Binding FaceFrameCount}"/> <TextBlock Style="{StaticResource VioletTB}" Grid.Row="6" Text="{Binding RightHandState}"/> <TextBlock Style="{StaticResource VioletTB}" Grid.Row="7" Text="{Binding FaceEngaged}"/>

</Grid></Page>



La deuxième étape est de rentrer dans le développement avec le langage C#. Le fichier MainPage.xaml.cs regroupe toutes les fonctionnalités que l’application aura.

using System;using System.ComponentModel;using System.Diagnostics;using System.Linq;using System.Runtime.CompilerServices;using Windows.UI.Xaml;using Windows.UI.Xaml.Controls;using WindowsPreview.Kinect;using KinectMinimalFaceTrackingDemo.Annotations;using Microsoft.Kinect.Face;

// You should also add the following post-build event to the project properties://// xcopy "C:\Program Files (x86)\Microsoft SDKs\Windows\v8.0\ExtensionSDKs\Microsoft.// Kinect.Face\2.0\Redist\CommonConfiguration\x64\NuiDatabase" "NuiDatabase" /e /y /i /r//// Although the app works "OK" without, face gestures are much more reliable with the // inclusion of the NuiDatabase (which seems like it includes definitions for face features)

namespace KinectMinimalFaceTrackingDemo{ public sealed partial class MainPage : Page, INotifyPropertyChanged { public event PropertyChangedEventHandler PropertyChanged;

/// <summary>Status of the Kinect device</summary> public string KinectStatus { get { if(_kinectSensor == null) return "Off"; return _kinectSensor.IsAvailable ? "Available" : "Not available"; } }

/// <summary>Flags if we're actively tracking a body or not</summary> public bool TrackingBody { get { return _trackingBody; } set { _trackingBody = value; OnPropertyChanged();} } /// <summary>Flags if we're actively tracking a face</summary> public bool TrackingFace { get { return _trackingFace; } set { _trackingFace = value; OnPropertyChanged();} }

/// <summary>Keeps count of the number of body frames received</summary> public int BodyFrameCount { get { return _bodyFrameCount; } set { _bodyFrameCount = value; OnPropertyChanged();} }



Détection du corps avec Kinect

Généralités

Les fonctions “Skeletal Tracking” permet à Kinect de reconnaître les gens et suivre leurs actions. Grâce à l’utilisation de la caméra infrarouge, Kinect peut reconnaître jusqu'à 6 utilisateurs dans le champ de vision du capteur. Parmi ceux-ci, jusqu'à 2 utilisateurs peuvent être suivis en détail. Une application peut localiser les articulations des utilisateurs suivis dans l'espace et de suivre leurs mouvements dans le temps.

“Skeletal Tracking” est optimisée pour reconnaître les utilisateurs debout ou assis, et face à la Kinect. Cependant les positions en latérale peuvent fournir certaines difficultés car parfois elles peuvent ne pas être visibles par le capteur.Pour être reconnu, les utilisateurs doivent simplement être en face du capteur, et s’ assurer que le capteur peut détecter leur tête et le haut de leur corps.



Le champs de vision de la Kinect est déterminé par les réglages de la caméra infrarouge et qui sont réglés avec “DepthRange Enumeration”. Par défaut, Kinect peut voir des gens debout entre 0,8 mètres et 4,0 mètres.

Détection de la profondeur Dans le cas de la profondeur (récupérée via les capteurs infrarouges), c’est un tableau de Byte qui sera récupéré mais celui-ci ne va pas représenter une image mais un tableau de distances. Concrètement, chaque case du tableau représente à quel distance le point représenté par le pixel est par rapport au capteur.La première chose à faire est de modifier l’initialisation du Runtime pour que Kinect prévienne lorsque l’on peut récupérer des informations de profondeur. Deux choix s’offrent à nous :

Ou

RunTimeOptions.UseDepth permet de récupérer uniquement l’information sur la distance d’un pixel alors que RunTimeOptions.UseDepthAndPlayerIndex permet également de savoir si ce pixel fait partie d’un joueur ou non et, le cas échéant, de savoir lequel.À noter qu’il faut que Kinect trouve votre squelette pour savoir que vous êtes un joueur et donc fournir correctement cette information. Pour accéder a ces informations on ajoute RuntimeOptions.UseSkeletalTracking. Ainsi on utilise la profondeur avec information sur le joueur.Puis il faut ouvrir le flux pour la profondeur.

Ensuite on s’abonne à l’événement DepthFrameReady du Runtime qui sera déclenché environ 30 fois par seconde.

_nui.Initialize(RuntimeOptions.UseColor | RuntimeOptions.UseDepth);

_nui.Initialize(RuntimeOptions.UseColor|RuntimeOptions.UseDepthAndPlayerIndex | RuntimeOptions.UseSkeletalTracking);

_nui.DepthStream.Open(ImageStreamType.Depth, 2, ImageResolution.Resolution320x240, ImageType.DepthAndPlayerIndex);

_nui.DepthStream.Open(ImageStreamType.Depth, 2, ImageResolution.Resolution320x240, ImageType.DepthAndPlayerIndex);



On va alors pouvoir récupérer l’objet PlanarImage de l’argument de typeImageFrameReadyEventArgs.

Récupérer les distances à partir du tableau d’octets

Le PlanarImage n’est pas une image en soit, il s’agit plutôt d’un tableau de Byte qui va nous permettre de connaitre à quelle distance du capteur se situe le point représenté par un pixel. Chaque pixel contient une distance qui est enregistrée sur 2 octets. Le schéma ci-dessous représente le contenu de ces 2 octets en fonction du type de donnée de profondeur choisie dans l’initialisation (Depth tout seul ou Depth & PlayerIndex).

Détail de composition des octets pour la distance

À noter que les données entrées dans ce schéma ne sont ABSOLUMENT pas représentatives de ce qui pourrait arriver.

void nui_DepthFrameReady(object sender, ImageFrameReadyEventArgs e){ PlanarImage profondeurImage = e.ImageFrame.Image;}



Il faut donc faire une méthode qui va nous retourner la distance pour un pixel donné. Il faut tout de même avant ça savoir que la distance est la combinaison des 2 octets et que l’octet ayant l’indice le plus grand dans le tableau du PlanarImage est l’octet qui a le poids le plus fort (donc qui doit être le plus à gauche).Il va donc être nécessaire de faire un « déplacement de bit », bitshift en anglais qui va nous permettre de replacer le tout à un endroit cohérent et récupérer la distance. Voici la méthode qui permet de retourner la distance en millimètre d’un pixel sans le player index :

On voit bien ici que l’on décale de 8 bits vers la gauche (donc d’un octet entier) le deuxième octet avant de combiner les deux de façon à retrouver un entier codé sur 2 octets cohérents.Voici la même méthode mais cette fois-ci en prenant en compte le cas où l’on a le PlayerIndex d’indiqué dans les octets :

On décale le premier octet de 3 bits vers la droite pour faire sortir le PlayerIndex de l’octet puis on lui colle devant le deuxième octet (un décalage de 5 vers la gauche suffit puisque 3 bits ont été enlevé sur le premier).Maintenant il est possible de créer une image personnelle qui représentera les distances récupérées par Kinect.

private int GetDistance(byte byte1, byte byte2){ int distance = (int)(byte1 | byte2 << 8); return distance;}

private int GetDistanceWithPlayerIndex(byte byte1, byte byte2){ int distance = (int)(byte1 >> 3 | byte2 << 5); return distance;}



Construire une Depth Map (image de profondeur) Pour cela, il faut savoir que Kinect peut récupérer les distances dans un spectre allant de

850mm à 4000mm, toute distance de 0 signifie que le capteur ne connait pas l’information (peut être causé par une distance trop proche, une réflectivité trop importante, …).La méthode qui créée l’image en binaire à partir du tableau de byte des distances :

private byte[] CreateImageFromDistances(PlanarImage distanceImage){ // On récupère la largeur et la hauteur de "l'image" des distances (ici normalement 320x240) int width = distanceImage.Width; int height = distanceImage.Height; // On créé le tableau de byte qui contiendra notre image réelle en binaire que l'on affichera plus tard byte[] imageCreeeBinaire = new byte[width*height]; // On créé l'index qui permettra de savoir où l'on est de la création. int positionCreation = 0; // On définit les bornes de visibilité de notre capteur pour le calcul de la couleur plus tard const int minDistance = 850; const int maxDistance = 4000; // On parcourt tout le tableau d'octet des distances par saut de 2 for (int i = 0; i < distanceImage.Bits.Length - 1; i += 2) { // On récupère la distance du pixel en cours de traitement int distance = GetDistanceWithPlayerIndex(distanceImage.Bits[i], distanceImage.Bits[i + 1]); // On calcule le poids de la couleur (de 0 à 255) en fonction de la distance imageCreeeBinaire[positionCreation] = (byte)(255 * Math.Max(distance - minDistance, 0) / maxDistance); // On incrémente la position de la création de l'image positionCreation++; } // Enfin, on retourne l'image binaire créée return imageCreeeBinaire;



Il ne reste plus qu’à appliquer le tableau d’octets donné par cette méthode en tant que source d’un contrôle WPF Image qu’il faut créer.

Utilisation du PlayerIndex Le PlayerIndex (qui se récupère sur le premier octet des données de distance pour un

pixel) peut prendre 6 valeurs différentes :

• 0 signifie que le pixel concerné ne correspond pas à un joueur

• 1 signifie que le pixel concerné correspond au squelette 0

• 2 signifie que le pixel concerné correspond au squelette 1 etc..

En théorie il est possible de détecter 6 joueurs différents avec les données de profondeur (par contre seulement 2 squelettes). En faisant référence au schéma des données pour la distance et le PlayerIndex, on peut en déduire cette méthode pour retrouver le PlayerIndex :

En effet, la représentation de 7 en binaire est 00000111, ce qui signifie que l’opération mettra à 0 tous les bits qui ne concernent pas le PlayerIndex et nous retournera ainsi la bonne information.Pour finir voici la méthode CreateImageFromDistances modifiée de façon à ce que les personnes apparaissent en couleur lorsqu’ils sont détectés. La plus grosse différence est le type de données que l’on retourne, notre image finale n’aura plus besoin d’1 octet par pixel mais de 3 qui définissent chacun la quantité d’une couleur de base (rouge, vert et bleu).

void nui_DepthFrameReady(object sender, ImageFrameReadyEventArgs e){ // On récupère "l'image" prise par le capteur infrarouge PlanarImage imageProfondeur = e.ImageFrame.Image; // On créé l'image binaire en échelle de gris à partir des informations de distance byte[] imageBinaire = CreateImageFromDistances(e.ImageFrame.Image); // Puis tout comme avec la couleur, on définit la source pour le contrôle WPF imageDepth.Source = BitmapSource.Create( imageProfondeur.Width, imageProfondeur.Height, 96, 96, PixelFormats.Gray8, null, imageBinaire, imageProfondeur.Width);

private int GetPlayerIndex(byte octet){ return (int)(octet & 7);}



private byte[] CreateImageFromDistances(PlanarImage distanceImage){ // On récupère la largeur et la hauteur de "l'image" des distances (ici normalement 320x240) int width = distanceImage.Width; int height = distanceImage.Height; // On créé le tableau de byte qui contiendra notre image réelle en binaire que l'on affichera plus tard byte[] imageCreeeBinaire = new byte[width*height*3]; // On créé l'index qui permettra de savoir où l'on est de la création. int positionCreation = 0; // On définit les bornes de visibilité de notre capteur pour le calcul de la couleur plus tard const int minDistance = 850; const int maxDistance = 4000; // On parcourt tout le tableau d'octet des distances par saut de 2 for (int i = 0; i < distanceImage.Bits.Length - 1; i += 2) { // On regarde si le pixel appartient à un joueur if (GetPlayerIndex(distanceImage.Bits[i]) != 0) { // Si c'est le cas, on colorie le joueur en fonction de son numero switch (GetPlayerIndex(distanceImage.Bits[i])) { // Si c'est le squelette 0 case 1: // On met le rouge au max, les autres couleurs à 0 imageCreeeBinaire[positionCreation] = 255; imageCreeeBinaire[positionCreation + 1] = 0; imageCreeeBinaire[positionCreation + 2] = 0; break; // Si c'est le squelette 1 case 2: // On met le vert au max, les autres couleurs à 0 imageCreeeBinaire[positionCreation] = 0; imageCreeeBinaire[positionCreation + 1] = 255; imageCreeeBinaire[positionCreation + 2] = 0; break; // Si c'est le squelette 2 case 3: // On met le bleu au max, les autres couleurs à 0 imageCreeeBinaire[positionCreation] = 0; imageCreeeBinaire[positionCreation + 1] = 0; imageCreeeBinaire[positionCreation + 2] = 255; break; default: imageCreeeBinaire[positionCreation] = 255; imageCreeeBinaire[positionCreation + 1] = 0; imageCreeeBinaire[positionCreation + 2] = 255; break; } } // Sinon, on colorie en echelle de gris en fonction de la distance else { // On récupère la distance du pixel en cours de traitement int distance = GetDistanceWithPlayerIndex(distanceImage.Bits[i], distanceImage.Bits[i + 1]);



Ne pas oublier également de modifier le BitmapSource.Create du contrôle WPF.

Maintenant lorsque le capteur détecte entièrement le squelette, la silhouette apparait colorée.

// On calcule le poids de la couleur (de 0 à 255) en fonction de la distance et on l'applique aux 3 couleurs pour obtenir du gris byte grayIntensity = (byte)(255 * Math.Max(distance - minDistance, 0) / maxDistance); imageCreeeBinaire[positionCreation] = grayIntensity; imageCreeeBinaire[positionCreation + 1] = grayIntensity; imageCreeeBinaire[positionCreation + 2] = grayIntensity; } // On incrémente de 4 la position de la création de l'image (les 3 couleurs + un octet vide pour respecter le format de pixel) positionCreation+=3; } // Enfin, on retourne l'image binaire créée return imageCreeeBinaire;}

imageDepth.Source = BitmapSource.Create( imageProfondeur.Width, imageProfondeur.Height, 96, 96, PixelFormats.Bgr24, null, imageBinaire, imageProfondeur.Width * 3);



La récupération du squelette Qu’est-ce que le Squeletal Tracking ? Il s’agit tout simplement et comme son nom l’indique

du fait que Kinect va repérer un squelette et va commencer à le suivre afin de savoir à tout moment où se trouve la main droite ou le genou gauche par exemple. Pour que ce tracking soit possible, il faut que le corps soit visible en quasi totalité par le capteur. Dès lors que Kinect a repéré un joueur et son squelette il va alors pouvoir être possible de récupérer les informations sur chaque os de chaque personne. À noter que Kinect ne peut observer et suivre le squelette de 2 personnes à la fois mais pas plus.Pour ce qui est des os que peut détecter le capteur, il est possible de récupérer les informations d’un total de 20 os, voici le schéma de la documentation du SDK qui montre quels sont les os qui sont identifiés sur un corps humain.

Les joints du corps humains détectés pas Kinect



À l’image de ce qui a été fait avec les données de profondeur, il va falloir se préparer dans le code à recevoir les informations du squelette. La première chose à faire est de signaler au Runtime Kinect qui va recevoir ces informations. Normalement, ceci est déjà fait avec les arguments de la méthode Initialize lorsque le PlayerIndex est récupéré.

Le RuntimeOptions.UseSkeletalTracking est la partie la plus importante. Il faut ensuite s’abonner à l’évènement SkeletonFrameReady qui sera appelé dès lors qu’un squelette ou deux sont visibles par le capteur.

Il faut ensuite créer la méthode appelée par l’évènement et l’implémenter pour traiter les données fournies par Kinect.

_nui.Initialize(RuntimeOptions.UseColor|RuntimeOptions.UseDepthAndPlayerIndex | RuntimeOptions.UseSkeletalTracking);

_nui.SkeletonFrameReady += nui_SkeletonFrameReady;

void nui_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e) {}



Traitement des informations du squelette On peut remarquer que la méthode appelée par l’événement SkeletalFrameReady fournie

en argument un objet de type SkeletonFrameReadyEventArgs, c’est donc lui qui contient toutes les informations relatives aux squelettes visibles par Kinect.Bien que Kinect ne puisse suivre que 2 squelettes, cet objet fournit un tableau de 6 squelettes. En effet, les informations de profondeur ont un PlayerIndex codé sur 3 bits, Kinect peut donc « voir » jusqu’à 6 joueurs mais pour des questions de fluidité ne peut calculer et suivre le squelette que de 2 d’entre eux.Pour bien voir cela, il faut commencer par récupérer l’information sur la frame actuelle dans la méthode nui_SkeletonFrameReady.

L’événement ne se déclenchera que lorsque le joueur se trouve en quasi totalité dans le champs de vision du Kinect. Ensuite, la propriété la plus intéressante pour l’instant est Skeletons.

La propriété Skeletons au niveau du breakpoint (screen dans Visual Studio)

void nui_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e){ SkeletonFrame frame = e.SkeletonFrame;}



On peut aussi observer que le squelette qui représente le joueur suivi (ici le 6ème) à sa propriété TrackingState à Tracked alors que tous les autres sont à NotTracked. Il va donc falloir à chaque fois parcourir ce tableau de Skeleton et ne traiter que ceux qui ont le bon TrackingState.

Pour dessiner le squelette dans une application, il faut créer un Canvas qui servira de conteneur à des ellipses qui représenteront chacune un des os fournis par Kinect. Voici le code XAML correspondant.

On aura ici la tête, les deux épaules, les deux poignets, les deux hanches et les deux chevilles.Maintenant il faut retourner dans la méthode nui_SkeletonFrameReady pour bouger nos ellipses. On ne fait le traitement que sur les squelettes qui sont réellement suivies. Ces squelettes nous fournissent une propriété Joints qui est une collection de tous les joints accessibles. Pour accéder aux informations d’un os, on utilise une énumération incluse dans le SDK qui est JointID. Ainsi, si on veut par exemple récupérer les informations sur la tête, on va utiliser :

foreach (SkeletonData skeleton in frame.Skeletons){ if (skeleton.TrackingState == SkeletonTrackingState.Tracked) { // On traite le squelette }}

<Canvas Name="skeletonCanvas" Width="320" Height="240" HorizontalAlignment="Left" Margin="700,0,0,0"> <Ellipse Name="headEllipse" Width="20" Height="20" Fill="Red"/> <Ellipse Name="rightShoulderEllipse" Width="20" Height="20" Fill="Red"/> <Ellipse Name="rightWristEllipse" Width="20" Height="20" Fill="Red" /> <Ellipse Name="leftShoulderEllipse" Width="20" Height="20" Fill=« Red"/> <Ellipse Name="leftWristEllipse" Width="20" Height="20" Fill="Red"/> <Ellipse Name="spineEllipse" Width="20" Height="20" Fill="Red"/> <Ellipse Name="rightHipEllipse" Width="20" Height="20" Fill="Red"/> <Ellipse Name="rightAnkleEllipse" Width="20" Height="20" Fill="Red"/> <Ellipse Name="leftHipEllipse" Width="20" Height="20" Fill="Red"/> <Ellipse Name="leftAnkleEllipse" Width="20" Height="20" Fill="Red"/></Canvas>

Joint headJoint = skeleton.Joints[JointID.Head];



Ce joint nous donne accès une propriété Position qui donne la position en 3D sous forme de vecteur, cependant on souhaite projeter ceci dans un plan 2D (notre Canvas). Il existe une méthode fournie par le SDK qui permet de passer d’un vecteur 3D à 2 valeurs représentant le X et le Y de notre plan 2D.La méthode à utiliser est _nui.SkeletonEngine.SkeletonToDepthImage, voici l’exemple pour placer correctement l’ellipse de la tête en fonction des données récupérées via le Kinect.

À noter que l’on multiplie les valeurs trouvées x et y car la projection renvoie des valeurs comprises entre 0 et 1 pour indiquer de façon relative si l’on est plutôt d’un coté ou de l’autre du champs de vision.Afin d’éviter de réécrire les mêmes lignes de code pour chaque os, il faut créer une méthode qui se charge de faire toutes les actions nécessaires.

Ce qui donne donc plus que ceci dans la méthode nui_SkeletonFrameReady.

if (skeleton.TrackingState == SkeletonTrackingState.Tracked){ // On récupère le joint qui représente la tête Joint headJoint = skeleton.Joints[JointID.Head]; // On créé les variables qui contiendront les coordonnées projetées float x = 0; float y = 0; // On projette la position de la tête dans un espace 2D _nui.SkeletonEngine.SkeletonToDepthImage(headJoint.Position, out x, out y); // On place l'ellipse de la tête au bon endroit dans le canvas Canvas.SetLeft(headEllipse, x * skeletonCanvas.Width); Canvas.SetTop(headEllipse, y * skeletonCanvas.Height);}

private void ProjectAndMoveEllipse(Microsoft.Research.Kinect.Nui.Vector vecteurPosition, UIElement ellipse){ // On créé les variables qui contiendront les coordonnées projetées float x = 0; float y = 0; // On projette le vecteur en 2D _nui.SkeletonEngine.SkeletonToDepthImage(vecteurPosition, out x, out y); // On place l'ellipse avec les coordonnées projetées trouvées Canvas.SetLeft(ellipse, x * skeletonCanvas.Width); Canvas.SetTop(ellipse, y * skeletonCanvas.Height);}



A partir de là, il est possible de voir le squelette se déplacer.Le SDK n’inclut pas par défaut de système de détection de geste.

Le site suivant (en anglais) donne beaucoup d’indications pour détecter des gestes et de les enregistrer dans une bibliothèque. http://blogs.msdn.com/b/eternalcoding/archive/2011/07/04/gestures-and-tools-for-kinect.aspx

void nui_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e){ // On récupère la frame à traiter SkeletonFrame frame = e.SkeletonFrame; foreach (SkeletonData skeleton in frame.Skeletons) { if (skeleton.TrackingState == SkeletonTrackingState.Tracked) { // On utilise notre méthode pour bouger chaque ellipse en fonction de la position de son os associé ProjectAndMoveEllipse(skeleton.Joints[JointID.Head].Position, headEllipse); ProjectAndMoveEllipse(skeleton.Joints[JointID.ShoulderRight].Position, rightShoulderEllipse); ProjectAndMoveEllipse(skeleton.Joints[JointID.WristRight].Position, rightWristEllipse); ProjectAndMoveEllipse(skeleton.Joints[JointID.ShoulderLeft].Position, leftShoulderEllipse); ProjectAndMoveEllipse(skeleton.Joints[JointID.WristLeft].Position, leftWristEllipse); ProjectAndMoveEllipse(skeleton.Joints[JointID.Spine].Position, spineEllipse); ProjectAndMoveEllipse(skeleton.Joints[JointID.HipRight].Position, rightHipEllipse); ProjectAndMoveEllipse(skeleton.Joints[JointID.AnkleRight].Position, rightAnkleEllipse); ProjectAndMoveEllipse(skeleton.Joints[JointID.HipLeft].Position, leftHipEllipse); ProjectAndMoveEllipse(skeleton.Joints[JointID.AnkleLeft].Position, leftAnkleEllipse); } }}


http://blogs.msdn.com/b/eternalcoding/archive/2011/07/04/gestures-and-tools-for-kinect.aspx


Détection du visage avec Kinect

Tutoriel Kinect V2 permet de détecter un nombre important d’émotions sur les personnes “captées” par celle-ci.

1ÈRE ÉTAPE :

Appeler les différentes librairies nécessaires à la détection faciale.

2ÈME ÉTAPE :

Déclarer les objets nécessaires.

using Microsoft.Kinect;using WindowsPreview.Kinect;using Microsoft.Kinect.Face;

// The sensor objects.KinectSensor _sensor = null;

// The color frame reader is used to display the RGB streamColorFrameReader _colorReader = null;

// The body frame reader is used to identify the bodiesBodyFrameReader _bodyReader = null;

// The list of bodies identified by the sensorIList<Body> _bodies = null;

// The face frame sourceFaceFrameSource _faceSource = null;

// The face frame readerFaceFrameReader _faceReader = null;



3ÈME ÉTAPE

Initialiser Face Source avec les différentes détections voulues

4ÈME ÉTAPE

Connecter le visage au corps.

Tout est maintenant initialisé, nous pouvons désormais récupérer les différentes informations du visage.

_faceSource = new FaceFrameSource(_sensor, 0, FaceFrameFeatures.BoundingBoxInColorSpace | FaceFrameFeatures.FaceEngagement | FaceFrameFeatures.Glasses | FaceFrameFeatures.Happy | FaceFrameFeatures.LeftEyeClosed | FaceFrameFeatures.MouthOpen | FaceFrameFeatures.PointsInColorSpace | FaceFrameFeatures.RightEyeClosed); _faceReader = _faceSource.OpenReader(); _faceReader.FrameArrived += FaceReader_FrameArrived;

void BodyReader_FrameArrived(object sender, BodyFrameArrivedEventArgs e){ using (var frame = e.FrameReference.AcquireFrame()) { if (frame != null) { frame.GetAndRefreshBodyData(_bodies);

Body body = _bodies.Where(b => b.IsTracked).FirstOrDefault();

if (!_faceSource.IsTrackingIdValid) { if (body != null) { // On assigne l’ID du body au faceSource _faceSource.TrackingId = body.TrackingId; } } } }}



Fonctions et classes importantes La classe FaceFrame permet de récupérer les informations basiques :

→ Où se trouve le visage.

→ Où regarde-t-il.

→ Ses expressions (souri ou pas, ferme les yeux, si l’utilisateur porte des lunettes).

L’objet FaceFrameResult nous donne ces informations.

La classe FaceProperties retourne un tableau (en lecture seule) de valeurs renvoyant les différents états du visage de l’utilisateur. Exemple : FaceFrameResult.FaceProperties

Tableau répertoriant les différentes valeurs du visage

Différents résultats pouvant être retournés



Visuels

Comme expliqué, la détection faciale permet donc de récupérer des informations comme l’humeur, le port de lunettes etc.

Deux illustrations du résultat de Face Basics, disponible dans le SDK.



Détection du son avec la Kinect

Généralités

Kinect est livré avec un groupe de quatre microphones (Microphone array) qui permettent de capturer du son avec une très bonne qualité. en effet, directement sur le capteur, un processeur de traitement du signal (DSP) permet de supprimer le bruit de fond et d’annuler les effets d’écho.De plus, toujours grâce à son groupe de microphones, Kinect peut fournir la direction de la source sonore qu’il enregistre. On appelle cela du beamforming. Il devient alors par exemple possible de savoir qui parle dans une réunion (ou au moins de quelle direction vient la voix).Le Kinect pour Windows SDK sait également servir de source aux API Microsoft.Speech et ainsi il devient possible de faire de la reconnaissance vocale de ce que capture le SDK.

Pour tout cela, il suffit d’instancier un objet de classe KinectAudioSource :

Cette instanciation peut se faire en mode groupe de microphones ou microphone unique avec ou sans annulation de l’écho (Audio Echo Cancellation : AEC).Pour faire une capture, nous allons juste demander à notre source de nous fournir le flux audio :

Le flux audio arrive en 16khz et en mono 16bits.

var source = new KinectAudioSource {SystemMode = SystemMode.OptibeamArrayOnly};

byte[] buffer = new byte[16000];var audioStream = source.Start();audioStream.Read(buffer, 0, buffer.Length);


La Kinect V2 pour Windows détecte les entrées audio sur une plage de + et - 50° en face de la caméra

Entrée Audio


Pour utiliser les services de Beamforming, il faut mettre les microphones en mode détection des faisceaux sonores (beams) :

Il existe plusieurs modes pour détecter le faisceau sonore. Ici, nous demandons que le système sélectionne tout seul le faisceau sonore adéquat. Il serait aussi possible de faire la sélection manuellement, ou de ne prendre que le faisceau central ou encore de faire la moyenne de tous les faisceaux.

A partir du moment ou un mécanisme de sélection du faisceau sonore est en place, le système peut lever un évènement lorsque ce dernier se déplace :

L’angle ici retourné est exprimé en radians et est relatif au centre de votre Kinect. Si vous êtes en face de votre Kinect, un angle de 0 indique que le son vient d’en face du capteur, un angle < 0 indique que le son vient de gauche et un angle > 0 indique que le son vient de droite.

source.MicArrayMode = MicArrayMode.MicArrayAdaptiveBeam;

source.BeamChanged += source_BeamChanged;static void source_BeamChanged(object sender, BeamChangedEventArgs e){ Console.WriteLine("Angle : {0} radians", e.Angle);}


Le micro peu déterminer un faisceau de 5° sur une plage totale de 180°.Cette méthode peut être utilisée pour capter un son important comme une personne qui parle mais elle ne pourra pas enlever le bruit ambiant

Rayon d’action


Il est également possible à tout moment d’interroger source.SoundSourcePosition pour obtenir l’information d’angle :

Comme pour les positions des joints des squelettes, nous pouvons obtenir un niveau de qualité de l’information pour décider si nous souhaitons utiliser la donnée.En ce qui concerne les filtres (anti-écho et réduction du bruit) la classe KinectAudioSource permet aussi de contrôler les algorithmes pour obtenir les résultats attendus.

if (source.SoundSourcePositionConfidence > 0.9) Console.Write("Position (radians): {0}", source.SoundSourcePosition);




Cible la source sonore la plus élevée

Par défaut, la Kinect traque la source sonore la plus élevée.

Le micro peu supprimé 20dB du bruit ambiant ce qui améliore la fidélité audio. le niveau d'un chuchotement sonore. (Kinect pour Windows prend en charge l’annulation de son monophonique , mais pas stéréophonique). Le son provenant de l'arrière du capteur obtient une suppression supplémentaire de 6 dB pour ne par interférer.

Seuil Sonore

Il est également possible de di r iger la focal isat ion du microphones : Par exemple, il va se focaliser sur une personne et en suivre son déplacement grâce au squelette

Micro Directionnel


Choisir le bon environnement

Il y a quelques considérations environnementales qui auront un effet significatif sur la qualité de compression de l’application :

LE BRUIT AMBIANT

Le capteur se concentre sur la source de son la plus forte et tente d'annuler les autres bruits ambiant (jusqu'à environ 20 dB). Cela signifie que si il y a une autre conversation dans la salle (généralement autour de 60-65dB), la précision de la reconnaissance de la parole est réduite.

Imaginez donc le niveau sonore d’un centre commercial ou d’une cafétéria, la détection d’un son spécifique est pratiquement impossible. À un certain niveau , le bruit ambiant est inévitable , mais si votre application se exécutera dans un environnement bruyant , la voix pourrait ne pas être le meilleur choix d'interaction. Idéalement , vous ne devriez utiliser la voix si:


• L’environnement est calme et relativement petit : • Il n'y aura pas plusieurs personnes à parler en même temps:


Compatibilité avec Unity Pro

Nous n’avons pas testé nous-même la compatibilité entre Kinect Et Unity mais beaucoup de recherches ont été effectuées. Un plugin existe et est disponible au téléchargement à cette adresse : http://go.microsoft.com/fwlink/?LinkID=513177 .

Nous avons également trouvé plusieurs tutoriels simples permettant de gérer Kinect et Unity, basés la plupart sur du C#, et d’autres en Javascript. Ils sont simples à comprendre, et le code source de chaque projet est donné via des liens Github.Voici les différents tutoriels :

• http://unity3d.am/2014/07/04/kinectv2-unity3d-plugin-hand-control-tutorial-1/

• http://en.baydachnyy.com/2014/10/03/kinect-2-and-unity-3d-my-first-experience/

• http://peted.azurewebsites.net/kinect-4-windows-v2-unity-3d/


http://go.microsoft.com/fwlink/?LinkID=513177

http://unity3d.am/2014/07/04/kinectv2-unity3d-plugin-hand-control-tutorial-1/

http://en.baydachnyy.com/2014/10/03/kinect-2-and-unity-3d-my-first-experience/

http://peted.azurewebsites.net/kinect-4-windows-v2-unity-3d/


Bibliographie / Annexes http://pterneas.com/2014/12/21/kinect-2-face-basics/ http://msdn.microsoft.com/en-us/library/dn799271.aspx http://msdn.microsoft.com/fr-fr/windows/sdk-kinect-tuto http://www.scriptol.fr/xaml/http://rarcher.azurewebsites.net/Post/PostContent/44 http://www.kinectingforwindows.com/ http://msdn.microsoft.com/en-us/library/jj131039.aspx http://stackoverflow.com/questions/12080457/only-detect-speech-from-user-directly-in-front-of-kinect http://www.robmiles.com/s/The-Kinect-Sensor.pdf http://digitalerr0r.wordpress.com/2011/06/21/kinect-fundamentals-3-getting-data-from-the-depth-sensor/ http://learning.codasign.com/index.php?title=Distance_in_3D_Space http://blogs.msdn.com/b/eternalcoding/archive/2011/06/14/fr-prenez-le-contr-244-le-avec-kinect-pour-windows-sdk.aspx https://codedealer.wordpress.com/tag/kinect-2/ http://zugara.com/how-does-the-kinect-2-compare-to-the-kinect-1 http://peted.azurewebsites.net/kinect-4-windows-v2-unity-3d/ http://www.microsoft.com/en-us/kinectforwindows/develop/downloads-docs.aspx http://en.baydachnyy.com/2014/10/03/kinect-2-and-unity-3d-my-first-experience/ http://blogs.msdn.com/b/uk_faculty_connection/archive/2014/07/17/kinect-v2-preview-sdk-now-available-includes-unity3d-plugin.aspx http://unity3d.am/?s=kinect http://rarcher.azurewebsites.net/Post/PostContent/43 http://www.microsoft.com/en-us/download/details.aspx?id=44561


http://pterneas.com/2014/12/21/kinect-2-face-basics/

http://msdn.microsoft.com/en-us/library/dn799271.aspx

http://msdn.microsoft.com/fr-fr/windows/sdk-kinect-tuto

http://www.scriptol.fr/xaml/

http://rarcher.azurewebsites.net/Post/PostContent/44

http://www.kinectingforwindows.com/

http://msdn.microsoft.com/en-us/library/jj131039.aspx

http://stackoverflow.com/questions/12080457/only-detect-speech-from-user-directly-in-front-of-kinect

http://www.robmiles.com/s/The-Kinect-Sensor.pdf

http://digitalerr0r.wordpress.com/2011/06/21/kinect-fundamentals-3-getting-data-from-the-depth-sensor/

http://learning.codasign.com/index.php?title=Distance_in_3D_Space

http://blogs.msdn.com/b/eternalcoding/archive/2011/06/14/fr-prenez-le-contr-244-le-avec-kinect-pour-windows-sdk.aspx

https://codedealer.wordpress.com/tag/kinect-2/

http://zugara.com/how-does-the-kinect-2-compare-to-the-kinect-1

http://peted.azurewebsites.net/kinect-4-windows-v2-unity-3d/

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

http://en.baydachnyy.com/2014/10/03/kinect-2-and-unity-3d-my-first-experience/

http://blogs.msdn.com/b/uk_faculty_connection/archive/2014/07/17/kinect-v2-preview-sdk-now-available-includes-unity3d-plugin.aspx

http://unity3d.am/?s=kinect

http://rarcher.azurewebsites.net/Post/PostContent/43

http://www.microsoft.com/en-us/download/details.aspx?id=44561

Documents

Rapport de fonctionnement Kinect 2 - Kevin Marburger · 2015. 6. 12. · Capture avec Kinect 2 Caractéristiques de la Kinect Présentation de la Kinect La Kinect pour Windows est