Résumé

Dans cet article, nous explorerons comment le Microsoft Kinect peut être modifié pour fonctionner comme une caméra infrarouge (IR). Le Kinect est généralement connu comme une caméra en profondeur, mais avec quelques modifications, il peut capturer des images IR. En bloquant le projecteur ir et en ajoutant des lampes IR externes, nous pouvons permettre au Kinect de détecter et d’enregistrer la lumière infrarouge. Voici les points clés discutés dans cet article:

1. Le Kinect est un périphérique pour la console Xbox 360 qui permet aux utilisateurs d’interagir sans utiliser de contrôleur.
2. Le Kinect est une caméra de profondeur, ce qui signifie qu’elle peut calculer des distances entre elle-même et les objets dans son champ de vision.
3. En modifiant le Kinect, nous pouvons l’utiliser comme un appareil photo IR pour capturer les images IR.
4. Les composants du Kinect comprennent un projecteur IR, une caméra IR et une caméra RVB.
5. Le projecteur IR émet une grille de points IR sur des objets, que la caméra IR détecte pour calculer les images de profondeur.
6. Une description détaillée du Kinect et de ses utilisations potentielles peuvent être trouvées dans le livre “Making Things See” de Greg Borenstein.
7. Pour connecter le Kinect à un ordinateur, nous devons installer des logiciels et des bibliothèques spécifiques, tels que Openni, Nite, Sensor et Sensorkinect.
8. Après l’installation, nous pouvons vérifier le succès en exécutant des échantillons de scripts dans le traitement.
9. Afin de bloquer le projecteur IR, nous pouvons créer un bandeau à l’aide de ruban adhésif et de pads velcro.
10. Étant donné que le blocage du projecteur IR affecte la visibilité IR, les lampes IR externes doivent être ajoutées pour fournir un éclairage IR suffisant.
11. Pour construire des lampes IR, nous pouvons suivre un diagramme de circuit et calculer les valeurs de résistance pour les LED.

Questions et réponses

Q1: Quelle est la Kinect principalement connue pour?

A1: Le Kinect est principalement connu comme une caméra en profondeur, capable de calculer les distances entre les objets et lui-même.

Q2: Comment modifier le Kinect pour fonctionner comme une caméra infrarouge?

A2: Le Kinect peut être modifié en bloquant le projecteur IR et en ajoutant des lampes IR externes pour capturer des images infrarouges.

Q3: Quels sont les composants du Kinect?

A3: Les composants du Kinect comprennent un projecteur IR, une caméra IR et une caméra RVB.

Q4: Comment le Kinect calcule-t-il des images de profondeur?

A4: Le Kinect calcule des images de profondeur en émettant une grille de points IR sur des objets, que la caméra IR détecte et utilise pour calculer les distances.

Q5: Y a-t-il des ressources recommandées pour en savoir plus sur le Kinect?

A5: Oui, “Faire des choses voir” par Greg Borenstein fournit une description détaillée du Kinect et de ses applications potentielles.

Q6: Quels logiciels et bibliothèques sont nécessaires pour connecter le Kinect à un ordinateur?

A6: Les logiciels et bibliothèques nécessaires incluent Openni, Nite, Sensor et Sensorkinect.

Q7: Comment pouvons-nous vérifier l’installation réussie du logiciel Kinect?

A7: En exécutant des échantillons de scripts dans le traitement, tels que la profondeur et la profondeur de la profondeur, nous pouvons vérifier si l’installation a réussi.

Q8: Comment bloquer le projecteur infrarouge du Kinect?

A8: Un bandeau peut être créé en utilisant du ruban adhésif et des coussinets velcro pour couvrir et bloquer le projecteur IR.

Q9: Pourquoi est-il nécessaire d’ajouter des lampes IR externes?

A9: Le blocage du projecteur IR réduit la visibilité IR, donc les lampes IR externes sont nécessaires pour fournir un éclairage IR suffisant pour capturer les images IR.

Q10: Comment pouvons-nous construire des lampes IR pour améliorer la visibilité IR?

A10: Après un diagramme de circuit et calculer les valeurs de résistance pour les LED, nous pouvons construire des lampes IR pour améliorer la visibilité IR.

Conclusion

Dans cet article, j’ai exploré comment le Microsoft Kinect peut être modifié pour fonctionner comme une caméra infrarouge. Avec les bonnes modifications et ajouts, le Kinect peut capturer des images infrarouges et fournir de nouvelles possibilités pour divers projets. Ce projet nous permet d’exploiter le potentiel du Kinect au-delà de ses utilisations traditionnelles, démontrant sa polyvalence et son extensibilité.

Utilisation d’un Kinect comme caméra infrarouge

Borenstein, Greg, Faire voir les choses, O’Reilly Media, Inc., 978-1-449-30707-3, janvier 2012.

Kinect utilise-t-il l’infrarouge

О этой срранице

Ыы зарегистрtures. С помощюю ээой страницы ыы сжжем оределить, что заES’t. П’t?

Эта странdent к Te. Странdent. До ээого момента для исоллash.

Источником заves просов может слжжж Вve ыыы заES’t. Еслèe Вы ис démar. Обратитесь к своему ситемному адмииииии. Подробнее.

Проверка по слову может также появляться, ели Вы Вводите сложные заы, оычно рссзevretic емами, или же Вводите заES’t.

Utilisation d’un Kinect comme caméra infrarouge

Ce projet montrera comment le Microsoft Kinect peut être modifié pour être utilisé comme une caméra infrarouge (IR).

• Temps requis: 2-3 heures
• Imprimez ce projet

Par Damon Conover

Damon Conover

Le Kinect est un périphérique pour la console Xbox 360 qui permet à un utilisateur d’interagir avec la Xbox 360 sans toucher un contrôleur. Une description générale du Kinect est qu’il s’agit d’une caméra de profondeur. Cela signifie que vous pouvez placer des objets devant lui, et il calculera la distance de celui-ci aux objets, créant ainsi une image de profondeur. Par conséquent, le Kinect peut fournir les emplacements des objets dans une image par rapport à lui-même, et ces informations peuvent être utilisées dans une variété de projets. De plus, le Kinect contient de nombreux composants qui, avec de légères modifications, peuvent être utilisés à de nouvelles fins. Par exemple, ce projet montrera comment le Kinect peut être utilisé comme une caméra infrarouge (IR).

Pour une description détaillée du fonctionnement du Kinect et de la façon dont il peut être utilisé dans différents projets, je vous recommande de lire Faire voir les choses par Greg Borenstein (http: // boutique.oreilly.com / produit / 06369200…). L’image de l’étape 1 montre les composants du Kinect qui sont nécessaires pour comprendre ce projet. Le projecteur ir brise une grille de points IR sur les objets devant lui. Nous ne pouvons pas voir les points, mais la caméra IR peut les détecter. En utilisant le motif des points sur chaque objet, le Kinect est capable de calculer l’image de profondeur. Le composant final est une caméra RVB similaire à une webcam standard.

Étapes du projet

Installez le logiciel nécessaire pour connecter le Kinect à votre ordinateur

Suivez ici les instructions spécifiques à la plate-forme pour:

Installez les pilotes Openni, Nite, Capteur et Sensorkinect

Installez la bibliothèque SimpleOpenni pour le traitement

Vérifiez que l’installation a réussi

Commencez à traiter et exécutez les exemples de profondeur et de profondeur.

Fournir de l’énergie à votre Kinect et le connecter à votre ordinateur via le port USB.

Allez dans le fichier → Exemples → Bibliothèques contribuées → SimpleOpenni → Openni.

Double-cliquez sur l’exemple que vous souhaitez exécuter (par exemple, Depthinfrared), et l’exemple de script s’ouvrira.

Cliquez sur le bouton Exécuter et une image apparaît sur votre écran. Pour le script en profondeur, une image de profondeur sera à gauche et une image IR sera à droite, comme indiqué à gauche.

Bloquer le projecteur IR

Comme on peut le voir à l’étape précédente, l’image IR produite par le script en profondeur contient un motif de points que nous souhaitons supprimer.

Pour ce faire, créez un bandeau pour couvrir le projecteur ir.

Prenez deux bandes de ruban adhésif, chacune supérieure à 9 pouces, et placez-en une de telle sorte qu’elle chevauche légèrement l’autre. Puis répétez en utilisant deux autres bandes de ruban adhésif.

Prenez les deux bandes de ruban adhésif à double large.

Coupez la bande résultante à 9 pouces de longueur.

Placer les coussinets de velco à une extrémité de la bande, enrouler la bande autour du Kinect, couvrant le projecteur IR et placer les coussinets de velco opposés de telle sorte que la bande est maintenue, comme illustré à gauche.

Construisez les lampes IR

Maintenant que le projecteur IR a été bloqué, il n’y a plus assez de lumière IR pour que la caméra IR puisse générer une bonne image.

Par conséquent, l’éclairage IR externe doit être ajouté. Le diagramme du circuit à gauche montre une conception possible pour deux lampes IR.

Connectez l’alimentation CC à la prise d’alimentation et mesurez sa tension (VDC) à l’aide d’un multimètre. Pour mon alimentation, VDC = 15.6 V.

Recherchez la tension vers l’avant typique (VF) et le courant avant maximum (si, max) des LED. Les miens étaient vf = 1.5 V et si = 20 mA, respectivement.

Calculez la résistance (r1 = r2 = r3 = r4) nécessaire pour limiter le courant à travers chaque série de six LED. J’ai utilisé des résistances de 360 ​​Ω. R> ((vdc – (# des LED) * vf) / if)

Construisez les lampes IR (suite)

Sur la moitié d’un PCB, placez six LED et une résistance. Fils de soudure reliant les LED, cathode à l’anode et la résistance. Répéter pour l’autre moitié du PCB. Puis souder un fil reliant les anodes libres et un autre fil reliant l’extrémité libre des résistances.

Souder un long fil rouge aux anodes connectées et un long fil noir aux résistances connectées.

(Facultatif) Utilisez Sugru pour maintenir les longs fils au PCB afin de fournir un certain soulagement de la contrainte.

Percez des trous au fond d’une tasse en plastique, alimentez les fils à travers le trou et appuyez fermement sur le PCB dans la tasse. Si le PCB ne tient pas étroitement, utilisez Sugru pour le maintenir en place.

Répétez les quatre étapes précédentes pour la deuxième lampe.

Construisez le contrôleur d’intensité de lampe

Utilisez des étriers pour mesurer les tailles des trous nécessaires pour monter les deux pots, commutateur, porte-fusibles et prise d’alimentation.

Percez les trous dans l’enceinte du projet et montez le matériel. De plus, percez deux petits trous pour que les fils entrent. Lorsque vous planifiez où placer chaque trou, gardez à l’esprit où chaque partie se situe dans l’enceinte, afin de vous assurer que tout.

Vous devrez ouvrir le trou pour la prise électrique à l’aide d’un outil Dremel ou avec un couteau.

Placer Sugru à l’intérieur et à l’extérieur de l’enceinte pour maintenir le cric en place.

Construisez le contrôleur d’intensité de lampe (suite)

Tournez chaque pot en position qui sera le réglage bas, puis utilisez votre multimètre’S testeur de continuité pour trouver les deux broches qui seront utilisées dans le circuit (le testeur bip).

Utilisez également le testeur de continuité pour déterminer quelles deux broches sur l’interrupteur sont connectées lorsque l’interrupteur est en place et lesquels sont connectés lorsque le commutateur est en panne.

Fils courts de soudure reliant les pièces dans le boîtier, selon le diagramme du circuit.

Souder deux longs fils rouges dans les pots et deux longs fils noirs à l’interrupteur, puis les piquer à travers les deux petits trous.

Visser sur l’enceinte’S couvercle et placer un fusible dans le porte-fusibles.

Tournez les fils qui sortant des lampes avec les fils entrant dans le contrôleur (rouge-rouge, noir à noir), souder si nécessaire, puis couvrir les fils exposés avec du ruban électrique.

Monter le kinect et les lampes

Placez le kinect sur une surface, pointé sur l’objet que vous souhaitez image.

(Facultatif) Connectez le Kinect au connecteur du trépied puis à un trépied. Connectez le trépied à un stand de bague et positionnez-le devant la surface d’imagerie.

Montez les lampes dans une orientation de telle sorte que la surface d’imagerie sera éclairée.

(Facultatif) Connectez les lampes au stand de l’anneau et maintenez-les en position avec les pinces, les charnières et le ruban.

Branchez l’alimentation de l’adaptation murale dans une prise, puis connectez-la au contrôleur d’intensité de lampe via la prise d’alimentation.

Effectuer l’expérience

Prenez un morceau de papier de construction et dessinez un objet sur le côté gauche et un autre sur le côté droit, à l’aide d’un crayon à charbon de bois.

Couleur sur l’objet gauche avec le pastel bleu phtalo et colorez sur l’objet droit avec le pastel bleu prussien.

Placer le papier devant la caméra.

Open Traitement, créez des scripts rgb_save.PDE et ir_save.PDE (Le code est fourni dans le code joint.pdf), modifiez le code de telle sorte que les fichiers et les noms de chemin sont appropriés pour votre ordinateur, exécutez rgb_save.PDE, puis courir ir_save.PDE.

Allumez les lampes en retournant l’interrupteur, puis ajustez l’intensité à l’aide des boutons du contrôleur. Vous ne pourrez pas voir la lumière IR émise par les LED, alors utilisez la vidéo IR capturée par l’appareil photo pour déterminer l’intensité souhaitée. Vous devrez à nouveau exécuter les deux scripts, après avoir réglé les lampes.

L’image résultante, montrée sur la gauche, devrait afficher une image couleur en haut et une vidéo IR en bas. Les résultats montrent que les deux pigments semblent similaires dans la partie couleur du spectre, mais très différent dans la partie IR.

Pour une description détaillée de la science derrière cette expérience, je vous recommande de lire les articles de Delaney et al. répertorié dans les références.

Les références

Wiki simple-Openni (consulté le 20 avril 2012). *** Les exemples inclus avec la boîte à outils sont particulièrement utiles.

Borenstein, Greg, Faire voir les choses, O’Reilly Media, Inc., 978-1-449-30707-3, janvier 2012.

Rass, Casey et Ben Fry, Commencer le traitement, O’Reilly Media, Inc., 978-1-449-37980-3, juin 2010.

Blake, Joshua, “Piratage de Kinect”, Make :, Volume 29, 124-133, http: // makeprojects.com / wiki / 29 # section_… (dernier consulté le 20 avril 2012).

Delaney, John K., Elizabeth Walmsley, Barbara H. Berrie et Colin F. Fletcher, “Imagerie multispectrale des peintures dans l’infrarouge pour détecter et cartographier les pigments bleus”, (Sackler Nas Colloquium) Examen scientifique de l’art: Techniques modernes en conservation et analyse, Actes de la National Academy of Sciences, 120-136, http: // www.sieste.edu / catalogue / 11413.HTML (dernier consulté le 20 avril 2012), 0-309-54961-2, 2005.

Delaney, John K., Jason G. Zeibel, Mathieu Thoury, Roy Littleton, Kathryn M. Morales, Michael Palmer, E. René de la Rie, “Spectroscopie d’imagerie de réflectance visible et infrarouge des peintures: cartographie pigmentaire et réflectographie infrarouge améliorée”, Q3A: Optics for Arts, Architecture, and Archaeology II, édité par Luca Pezzati et Renzo Salimbeni, Proc. de SPIE VOL. 7391, 2009.

Remerciements

L’auteur tient à remercier Dr. Murray Loew, de George Washington University, et Dr. John Delaney et Dr. E. Melanie Gifford, de la National Gallery of Art, Washington, D.C., pour leurs commentaires concernant la configuration expérimentale.

L’auteur souhaite également reconnaître le soutien aux bourses qu’il a reçus des récompenses de récompense pour les scientifiques des collèges (ARCS).

Conclusion

Remarque: Une fois que vous avez installé avec succès le logiciel pour connecter le Kinect à votre ordinateur, les seules étapes requises pour terminer ce projet sont: 1) bloquer le projecteur IR, 2) construire et monter une source de lumière IR de remplacement (avec une longueur d’onde centrale près de 830 nm) et 3) Experiment. Les détails de mon appareil et de mon expérience sont fournis, mais je vous encourage à modifier les détails en fonction des pièces et de l’équipement dont vous disposez et en fonction des choses que vous souhaitez imaginer. Bâtiment heureux!

Comment fonctionne la détection de mouvement dans Xbox Kinect

Le prototype de Microsoft’La caméra S Kinect et le microphone coûtent 30 000 $. À minuit jeudi matin, vous’Pourrai l’acheter pour 150 $ en tant que périphérique Xbox 360. Microsoft prévoit qu’il vendra 5 millions d’unités d’ici à Noël. Nous’auront plus de détails et un examen du système bientôt, mais pour […]

Sauver l’histoire

Sauver l’histoire

Le prototype de la caméra Kinect et du microphone de Microsoft a coûté 30 000 $. À minuit jeudi matin, vous pourrez l’acheter pour 150 $ en tant que périphérique Xbox 360.

Microsoft prévoit qu’il vendra 5 millions d’unités d’ici à Noël. Nous aurons bientôt plus de détails et un examen du système, mais pour l’instant, cela vaut la peine de prendre le temps de réfléchir à la façon dont tout cela fonctionne.

Caméra

La caméra de Kinect est alimentée par le matériel et les logiciels. Et il fait deux choses: générer une image tridimensionnelle (en mouvement) des objets dans son champ de vision, et reconnaître les êtres humains (en mouvement) parmi ces objets.

Les logiciels plus anciens ont utilisé des différences de couleur et de texture pour distinguer les objets de leurs arrière-plans. PrimeSense, la société dont la technologie alimente Kinect et la récente acquisition de Microsoft Canesta utilisent un modèle différent. La caméra transmet une lumière proche infrarouge invisible et mesure son “temps de vol” après qu’il reflète les objets.

Le temps de vol fonctionne comme sonar: si vous savez combien de temps la lumière prend pour revenir, vous savez à quelle distance un objet est. Jetez un grand champ, avec beaucoup de pings allant et venant à la vitesse de la lumière, et vous pouvez savoir à quel point beaucoup d’objets sont loin.

L’utilisation d’un générateur infrarouge résout également partiellement le problème de la lumière ambiante. Étant donné que le capteur n’est pas conçu pour enregistrer la lumière visible, elle n’obtient pas autant de faux positifs.

PrimeSense et Kinect vont plus loin et codent les informations dans la légère lumière. Au fur et à mesure que ces informations sont renvoyées, certaines d’entre elles sont déformées – qui à leur tour peuvent aider à générer une image plus fine de la texture 3D de ces objets, pas seulement leur profondeur.

Avec cette technologie, Kinect peut distinguer la profondeur des objets dans un centimètre et leur taille et leur largeur à moins de 3 mm.

Un contrôleur de jeu vidéo traditionnel est individuel et en série: c’est moi et tout ce que je contrôle sur l’écran contre vous et ce que vous contrôlez. Nous pourrions jouer en coopération, mais nous sommes essentiellement des entités discrètes isolées les unes des autres, manipulant des objets entre nos mains.

Un contrôleur de jeu vidéo est également un appareil hautement spécialisé. Il peut faire du travail léger comme une télécommande, mais les boutons, les d-pads, les joysticks, les accéléromètres, les gyroscopes, les mécanismes de rétroaction haptique et l’interface avec la console sont tous conçus pour communiquer des types d’informations très spécifiques.

Kinect est quelque chose de différent. Il est commun, continu et général: une interface utilisateur naturelle (ou NUI) pour le multimédia, plutôt qu’une interface graphique pour le jeu.

Mais il faut beaucoup de technologie pour faire une interface comme celle-ci se réunissent de manière transparente et “naturellement.”

Kinect 2 sur les laboratoires

Laborat 2: Affichage des données infrarouges

Temps estimé à terminer: 20 min

Ce laboratoire fait partie d’une série de laboratoires pratiques qui vous apprennent à créer un Windows 8.1 Application de magasin, en utilisant presque toutes les fonctionnalités disponibles du Kinect 2. Ceci est le deuxième laboratoire de la série. Dans ce laboratoire, vous apprendrez à récupérer le flux infrarouge du capteur Kinect et à présenter le flux en XAML en tant qu’image.

• Comment ouvrir le lecteur de cadre infrarouge sur le capteur Kinect dans le code.
• Comment recevoir le cadre infrarouge quand il est prêt.
• Comment convertir les données du cadre infrarouge en un bitmap monochrome
• Comment présenter le bitmap changeant en xaml.
• Comment obtenir et présenter des données sur l’état et la résolution du Kinect 2.

Exercice 1 – Affichage du cadre infrarouge

1. Ouvrez le Échantillon de Kinect 2 Solution dans Visual Studio, ou la copie que vous avez depuis la fin du laboratoire précédent.
2. Vous ouvrirez d’abord le Lecteur de cadre infrarouge Afin de récupérer les données infrarouges du capteur Kinect. Ouvrir le Page d’accueil.xaml.CS fichier à partir du Explorateur de solution. Le code que vous écrivez mettra en place le flux infrarouge, les événements et les données requises, avant d’ouvrir le capteur Kinect. Lorsque le Kinect commence à livrer des cadres, vous avez quelque chose qui reçoit l’entrée. Pour expliquer le code suivant, voici une description des variables importantes:
   • infrarouge – Lecteur pour les cadres infrarouges
   • infrarouge – Stockage intermédiaire pour recevoir des données de trame du capteur
   • pixels infrarouges – Stockage intermédiaire pour les données de trame converties en pixels de couleur pour l’affichage
   • bitmap – le scénariste qui remplacera le contenu d’une image dans XAML

Un nouveau cadre est reçu du lecteur de cadre lorsqu’il est prêt, généralement à environ 30 images par seconde. Chaque trame arrive sous forme de données infrarouges pour chaque pixel de la résolution de la caméra. Ces données sont converties en une gamme de couleurs en niveaux de gris, dans les InfraredPixels. Ensuite, les InfraredPixels sont utilisés pour écrire dans un objet bitmap.

Toutes ces variables doivent être initialisées avec la taille appropriée, qui est la taille du cadre infrarouge provenant du Kinect 2.

Pour initialiser correctement ces variables, copiez le code en surbrillance ci-dessous:

// . Autres espaces de noms en utilisant Windows.Ui.Xaml.Médias.Imagerie; espace de noms kinect2sample < public sealed partial class MainPage : Page < // Size of the RGB pixel in the bitmap const int private bytesPerPixel = 4; KinectSensor privé KinectSensor = null; Private WriteableBitmap Bitmap = null; // Cadre infrarouge InfraredFrameReader privé InfraredFrameReader = NULL; Private Ushort [] infraredFrameData = null; octet privé [] InfraredPixels = null; Public MainPage () < // one sensor is currently supported this.kinectSensor = KinectSensor.GetDefault(); // get the infraredFrameDescription from the // InfraredFrameSource Framedescription InfraredFrameDescription = ce.kinectsensor.Infrarouge.Framedescription; // Ouvrez le lecteur pour les cadres infrarouges ce.InfraredFrameReader = ce.kinectsensor.Infrarouge.OpenReader (); // gestionnaire de fils pour l'arrivée du cadre ce.infrarouge.Framerived + = ce.Reader_infraredFramerived; // allouer de l'espace pour mettre les pixels être // reçus et convertis ce.infraratedFrameData = New Ushort [infrarouge.Largeur * infrarouge.Hauteur]; ce.InfraredPixels = Nouvel octet [infrarouge.Largeur * infrarouge.Hauteur * bytesperpixel]; // Créez le bitmap à afficher ce.bitmap = Nouveau WriteableBitmap (infraratedFrameDescription.Largeur, infrarouge.Hauteur); // Ouvre le capteur ceci.kinectsensor.Ouvrir(); ce.Initializecomponent (); >>>

Public Scellé Classe partielle Main Page: Page < // . Reader privé_infraredframerive (expéditeur d'objet, Infrarouge < Bool infraredFrameProcessed = false; // infrarouge est idisposable Utilisation (infraratedFrame infraredFrame = e.Crampon.AcquireFrame ())  si (infrarouge != null) < Framedescription InfraredFrameDescription = infrarouge.Framedescription; // Vérifiez les données et écrivez les nouvelles données de trame infrarouge // à l'affichage bitmap si (((infrarouge.Largeur * infrarouge.Hauteur) ==.infrarouge.Longueur) && (InfraredFrameDescription.Largeur == ce.bitmap.Pixelwidth) && (InfraredFrameDescription.Hauteur == ce.bitmap.PixelHeight))  // Copiez les données de pixels de l'image à un tableau temporaire infrarouge.CopyFrameDatatoArray ( ce.InfraredFrameData); InfraredFrameProcessed = true; > > > // Nous avons obtenu un cadre, convertir et rendre si (infrarouge  ConvertinfraredDatatOpixels (); RenderPixelArray (ce.InfraredPixels); > > >

Public Scellé Classe partielle Main Page: Page < /// & ltsummary & gt /// la valeur la plus élevée qui puisse être retournée dans l'infrarouge. /// il est jeté à un flotteur pour la lisibilité dans le code de visualisation. /// & lt / résumé & gt const privé float infrarouge (flottant) Ushort.Valeur max; /// & lt / résumé & gt /// utilisé pour définir la limite inférieure, post-traitement, du /// des données infrarouges que nous rendrons. /// augmenter ou diminuer cette valeur définit une luminosité /// "mur" soit plus proche ou plus éloigné. /// & lt / résumé & gt const privé float infraredoutputvaluminimum = 0.01f; /// & ltsummary & gt /// la limite supérieure, post-traitement, du /// des données infrarouges qui rendront. /// & lt / résumé & gt const privé float infraredoutputvaluemaximum = 1.0f; /// & ltsummary & gt /// La valeur infrarouge de la valeur /// Valeur infrarouge moyenne de la scène. /// cette valeur a été sélectionnée en analysant la moyenne /// Intensité de pixels pour une scène donnée. /// cela pourrait être calculé à l'exécution pour gérer différents /// IR Conditions d'une scène (à l'extérieur vs à l'intérieur). /// & lt / résumé & gt Private const float infraredSceneValueAeAvert = 0.08f; /// & ltsummary & gt /// La valeur infrarouge de l'InfrarestandardDeviations spécifie /// le nombre d'écarts-types à appliquer /// InfraredScenevalueAverage. /// Cette valeur a été sélectionnée en analysant les données à partir d'une scène donnée. /// cela pourrait être calculé à l'exécution pour gérer différents /// IR Conditions d'une scène (à l'extérieur vs à l'intérieur). /// & lt / résumé & gt Private const float infraredScestandardDeviations = 3.0f; //. D'autres variables privées suivent>

Public Scellé Classe partielle Main Page: Page < // Reader_InfraredFrameArrived() before this. vide privé convertinfraredDatatOpixels () < // Convertir l'infrarouge en RVB int colorPixELindex = 0; pour (int i = 0; i < this.infraredFrameData.Length; ++i) // normaliser les données infrarouges entrantes (ushort) pour // un flotteur allant de l'infrarouge // à infrarouge-avant-valeur // 1. diviser la valeur entrante par le // Valeur maximale source IntensityRatio floc.InfraredFrameData [i] / Infrarouge // 2. divisé par le // (valeur moyenne de la scène * écarts-types) IntensityRatio / = InfraredScenevalueAepleft * infrarkedScestandardDeviations; // 3. Limiter la valeur à l'infrarouge IntensityRatio = mathématiques.Min (infrarouge, IntensityRatio); // 4. limiter la valeur inférieure infrarouge IntensityRatio = mathématiques.Max (infrarouge, IntensityRatio); // 5. convertir la valeur normalisée en un octet et utiliser // le résultat en tant que composants RVB requis par l'image Intensité d'octet = (octet) (IntensityRatio * 255.0f); ce.InfraredPixels [ColorPixeLindex ++] = intensité; //Bleu ce.InfraredPixels [ColorPixeLindex ++] = intensité; //Vert ce.InfraredPixels [ColorPixeLindex ++] = intensité; //Rouge ce.InfraredPixels [ColorPixeLindex ++] = 255; //Alpha > > >

Public Scellé Classe partielle Main Page: Page < // convertinfraredDatatOpixels () avant cela. vide privé renderpixelarray (octet [] pixels)  pixels.Copyto (ceci.bitmap.Pixelbuffer); ce.bitmap.Invalider(); Framedisplayimage.Source = ceci.bitmap; > >

& ltgrid background = "" & gt & ltgrid margin = "30" & gt & ltgrid.RowDefinitions & GT & ltrowdefinition height = "70" / & gt & ltrowdefinition height = "*" / & gt & ltrowdefinition height = "100" / & gt & LT / GRID.RowDefinitions> & Grille LtTextBlock.Row = "0" Style = "" Text = "kinect pour Windows 2" /> & ltimage x: name = "FramedisplayImage".Row = "1" Stretch = "uniforme" /> & LT / GRID> & LT / GRID>

Pour le plaisir, essayez d’éteindre les lumières. La lumière infrarouge est invisible pour les humains et donc la caméra fonctionne même dans l’obscurité totale, c’est la base du fonctionnement de la vision nocturne.

En tant que tâche facultative, essayez de modifier les valeurs constant qui ont été définies à l’étape 4 de cet exercice et voyez la différence qu’ils font dans la sortie du cadre résultant. Vous verrez la profondeur de visibilité et la luminosité du changement d’image en fonction de ces valeurs.

Laborat 2: Affichage des données infrarouges

Cet exercice vous montrera comment présenter des données de débogage utiles sur le cadre infrarouge actuel ainsi que l’état actuel du Kinect. Cet exercice vous aidera à dépanner tout problème avec le Kinect plus tard et à mettre en évidence la différence de résolution entre les cadres dans les exercices suivants.

Pour récupérer et afficher les données de trame du Kinect 2, suivez les étapes ci-dessous:

1. Premièrement, vous avez peut-être remarqué que le Designer Lors de la visualisation de XAML n’est pas disponible lors de la construction pour des architectures x64. Ce’s bien parce que Kinect 2 est également compatible avec l’architecture x86, à laquelle vous pouvez passer maintenant:
   1. Cliquez sur CONSTRUIRE alors Panneau de configuration… Pour ouvrir le gestionnaire de configuration.
   2. Cliquez sur la zone déroulante sous Solution active Plateforme: et sélectionnez x86.
   3. Cliquez sur Fermer.
   4. Ouvrez maintenant les propriétés du projet en cliquant avec le bouton droit sur le projet Kinect2Samp dans l’explorateur de solutions, puis en cliquant Propriétés.
   5. Clique le Construire Onglet à gauche, puis à côté Plateforme: sélectionner x86 de la liste déroulante.
   6. Cliquez sur DÉPOSER, alors Sauver tous ou frapper Ctrl + shift + s Pour enregistrer tous les fichiers.
   7. Construire et courir L’application pour vérifier les erreurs.
2. Les choses sur lesquelles vous devez vous concentrer sont les statut du kinect (s’il répond ou non) et le Résolution actuelle du cadre (ce qui est intéressant maintenant, et plus tard lorsque le laboratoire change de type cadre). Il est assez facile d’obtenir ces valeurs en code derrière. Pour permettre au XAML de se lier aux valeurs d’état, s’il change, vous devez implémenter le Inotifypropertychanged interface dans le Page d’accueil classe. Ensuite, le code déclenchera l’événement modifié de la propriété lorsque le statut change, et lorsque la description du cadre change. Pour configurer cela, copiez d’abord le code mis en évidence suivant dans les sections pertinentes du Page d’accueil classe pour initialiser et utiliser des propriétés modifiables:

   Utilisation du système.ComponentModel; espace de noms kinect2sample < public sealed partial class MainPage : Page, Inotifypropertychanged < // . consts and other private variables. private KinectSensor kinectSensor = null; chaîne privée StateStext = null; Private WriteableBitmap Bitmap = null; Private Framedescription CurrentFrameDescription; // Variables de cadre infrarouge. L'événement public PropertyChangedEventHandler PropertyChanged; Stratest de chaîne publique  obtenir ensemble  si ce.statistique != valeur)  ce.StatStext = valeur; si ce.Propriété changé != null)  ce.PropertyChanged (ceci, nouveau PropertyChangeDeventArgs ("StatusText")); > > > > Public Framedescription CurrentFrameDescription  obtenir ensemble  si ce. CurrentFrameDescription!= valeur)  ce. CurrentFrameDeScription = Value; si ce.Propriété changé != null)  ce.PropertyChanged (ceci, nouveau PropertyChangeDeventArgs ("CurrentFrameDescription")); > > > > // . >>

   Public MainPage () < // . // create the bitmap to display this.bitmap = new WriteableBitmap(infraredFrameDescription.Width, infraredFrameDescription.Height); ce.CurrentFrameDescription = infraratedFrameDescription; // Définir le notif d'événement isavailableChanged ce.kinectsensor.Isavailablechanged + = ce.Sensor_isavailableChanged; // utilise l'objet Window comme modèle de vue dans cet exemple ce.DataConText = this; // Ouvre le capteur ceci.kinectsensor.Ouvrir(); ce.Initializecomponent (); > Sensor de void privé_isavailableChanged (expéditeur de KinectSensor, IsavailableChangedEventargs args)  ce.Statustext = ceci.kinectsensor.Est disponible ? "Running": "Non disponible"; > 

   & Grille LtTextBlock.Row = "0" style = "" text = "kinect pour Windows 2" / & gt & LtstackPanel Grid.Row = "0" orientation = "horizontal" Horizontalalignment = "droite" VerticalAlignment = "Bottom" & gt & lttextblock text = "statut kinect:" / & gt & ltTextBlock text = "" / & gt & lttextblock text = ", framewidth" / & gt & ltTextBlock text = ", frameheight" / & gt & lt / stackpanel & gt & ltimage x: name = "FramedisplayImage".Row = "1" stretch = "uniforme" / & gt

   

   Essayez de débrancher le kinect et de voir le changement de statut. Ensuite, si vous branchez le Kinect, le statut se mettra à jour et le flux reviendra.

   Résumé

   Ce laboratoire vous a appris à Récupérer et utiliser un cadre infrarouge de l’appareil Kinect 2, et Utilisez ces données de trame pour rendre un bitmap visible être affiché en xaml.

   Il est intéressant de noter que la plupart de ce processus est manuel. Les données du Infrarouge n’est pas utilisable jusqu’à ce qu’il’s converti en bitmap. Ceci est par conception car il existe de nombreuses utilisations de la lumière infrarouge au-delà de la convertir en une image visible. Le Kinect 2 utilise la caméra infrarouge pour calculer les corps et les formes connues dans des conditions de faible luminosité. C’est pourquoi la résolution de l’infrarouge est si faible: il correspond à la résolution vue par le profondeur Pour calculer ce qui est et est’t une personne.

   Dans le laboratoire suivant, vous verrez la différence de résolution entre le colori.

   Il y a du code disponible qui est la solution de code terminée de l’œuvre dans ce laboratoire. Le prochain laboratoire commencera à partir de ce code.