HoloLens (1ère génération) et Azure 302 : Vision par ordinateur
Notes
Les tutoriels Mixed Reality Academy ont été conçus pour les appareils HoloLens (1re génération) et les casques immersifs de réalité mixte. Nous estimons qu’il est important de laisser ces tutoriels à la disposition des développeurs qui recherchent encore des conseils pour développer des applications sur ces appareils. Notez que ces tutoriels ne sont pas mis à jour avec les derniers ensembles d’outils ou interactions utilisés pour HoloLens 2. Ils sont fournis dans le but de fonctionner sur les appareils pris en charge. Il y aura une nouvelle série de tutoriels qui seront publiés à l’avenir et qui montreront comment développer pour HoloLens 2. Cet avis sera mis à jour avec un lien vers ces tutoriels lorsqu’ils seront publiés.
Dans ce cours, vous allez apprendre à reconnaître le contenu visuel dans une image fournie, à l’aide des fonctionnalités d’Azure Vision par ordinateur dans une application de réalité mixte.
Les résultats de la reconnaissance s’affichent sous forme de balises descriptives. Vous pouvez utiliser ce service sans avoir à effectuer l’apprentissage d’un modèle Machine Learning. Si votre implémentation nécessite l’apprentissage d’un modèle Machine Learning, consultez MR et Azure 302b.
Microsoft Vision par ordinateur est un ensemble d’API conçues pour fournir aux développeurs un traitement et une analyse d’images (avec des informations de retour), à l’aide d’algorithmes avancés, le tout à partir du cloud. Les développeurs chargent une image ou une URL d’image, et les algorithmes de l’API Microsoft Vision par ordinateur analysent le contenu visuel, en fonction des entrées choisies par l’utilisateur, qui peuvent ensuite retourner des informations, notamment l’identification du type et de la qualité d’une image, la détection des visages humains (retour de leurs coordonnées) et l’étiquetage ou la catégorisation des images. Pour plus d’informations, consultez la page API Azure Vision par ordinateur.
Après avoir terminé ce cours, vous disposerez d’une application HoloLens de réalité mixte, qui sera en mesure d’effectuer les opérations suivantes :
- À l’aide du mouvement Appuyez, l’appareil photo de l’HoloLens capture une image.
- L’image sera envoyée au service d’API Azure Vision par ordinateur.
- Les objets reconnus seront répertoriés dans un groupe d’interface utilisateur simple positionné dans la scène Unity.
Dans votre application, il vous appartient de savoir comment intégrer les résultats à votre conception. Ce cours est conçu pour vous apprendre à intégrer un service Azure à votre projet Unity. C’est votre travail d’utiliser les connaissances que vous obtenez de ce cours pour améliorer votre application de réalité mixte.
Prise en charge des appareils
| Cours | HoloLens | Casques immersifs |
|---|---|---|
| Réalité mixte - Azure - Cours 302 : Vision par ordinateur | ✔️ | ✔️ |
Notes
Bien que ce cours se concentre principalement sur HoloLens, vous pouvez également appliquer ce que vous apprenez dans ce cours à Windows Mixed Reality casques immersifs (VR). Étant donné que les casques immersifs (VR) n’ont pas de caméras accessibles, vous aurez besoin d’une caméra externe connectée à votre PC. À mesure que vous suivez le cours, vous verrez des notes sur les modifications que vous devrez peut-être utiliser pour prendre en charge les casques immersifs (VR).
Prérequis
Notes
Ce tutoriel est conçu pour les développeurs qui ont une expérience de base avec Unity et C#. Sachez également que les conditions préalables et les instructions écrites contenues dans ce document représentent ce qui a été testé et vérifié au moment de la rédaction (mai 2018). Vous êtes libre d’utiliser les logiciels les plus récents, comme indiqué dans l’article Installer les outils , mais il ne faut pas supposer que les informations de ce cours correspondent parfaitement à ce que vous trouverez dans les logiciels plus récents que ce qui est listé ci-dessous.
Nous vous recommandons d’utiliser le matériel et les logiciels suivants pour ce cours :
- Un PC de développement, compatible avec Windows Mixed Reality pour le développement de casque immersif (VR)
- Windows 10 Fall Creators Update (ou version ultérieure) avec le mode Développeur activé
- La dernière version du SDK Windows 10
- Unity 2017.4
- Visual Studio 2017
- Un casque Windows Mixed Reality immersif (VR) ou un Microsoft HoloLens avec le mode développeur activé
- Une caméra connectée à votre PC (pour le développement de casque immersif)
- Accès à Internet pour l’installation d’Azure et la récupération de l’API Vision par ordinateur
Avant de commencer
- Pour éviter de rencontrer des problèmes lors de la création de ce projet, il est fortement recommandé de créer le projet mentionné dans ce didacticiel dans un dossier racine ou proche de la racine (les chemins de dossier longs peuvent entraîner des problèmes au moment de la génération).
- Configurez et testez votre HoloLens. Si vous avez besoin de support pour configurer votre HoloLens, consultez l’article sur la configuration de HoloLens.
- Il est judicieux d’effectuer l’étalonnage et le réglage des capteurs lorsque vous commencez à développer une nouvelle application HoloLens (il peut parfois être utile d’effectuer ces tâches pour chaque utilisateur).
Pour obtenir de l’aide sur l’étalonnage, suivez ce lien vers l’article Étalonnage HoloLens.
Pour obtenir de l’aide sur le réglage des capteurs, suivez ce lien vers l’article Paramétrage du capteur HoloLens.
Chapitre 1 : Le portail Azure
Pour utiliser le service API Vision par ordinateur dans Azure, vous devez configurer une instance du service à mettre à la disposition de votre application.
Tout d’abord, connectez-vous au portail Azure.
Notes
Si vous n’avez pas encore de compte Azure, vous devez en créer un. Si vous suivez ce tutoriel dans une situation de classe ou de laboratoire, demandez à votre instructeur ou à l’un des surveillants de l’aide pour configurer votre nouveau compte.
Une fois que vous êtes connecté, cliquez sur Nouveau dans le coin supérieur gauche, recherchez Vision par ordinateur API, puis cliquez sur Entrée.
Notes
Le mot Nouveau a peut-être été remplacé par Créer une ressource, dans les portails plus récents.
La nouvelle page fournit une description du service API Vision par ordinateur. En bas à gauche de cette page, sélectionnez le bouton Créer pour créer une association avec ce service.
Une fois que vous avez cliqué sur Créer :
Insérez le nom souhaité pour ce service instance.
Sélectionnez un Abonnement.
Sélectionnez le niveau tarifaire qui vous convient. Si c’est la première fois que vous créez un service API Vision par ordinateur, un niveau gratuit (nommé F0) doit être disponible.
Choisissez un groupe de ressources ou créez-en un. Un groupe de ressources permet de surveiller, de contrôler l’accès, de provisionner et de gérer la facturation d’une collection de ressources Azure. Il est recommandé de conserver tous les services Azure associés à un seul projet (par exemple, ces labos) sous un groupe de ressources commun).
Si vous souhaitez en savoir plus sur les groupes de ressources Azure, consultez l’article sur les groupes de ressources.
Déterminez l’emplacement de votre groupe de ressources (si vous créez un groupe de ressources). L’emplacement serait idéalement dans la région où l’application s’exécuterait. Certaines ressources Azure ne sont disponibles que dans certaines régions.
Vous devez également confirmer que vous avez bien compris les conditions générales appliquées à ce service.
Cliquez sur Créer.
Une fois que vous avez cliqué sur Créer, vous devrez attendre que le service soit créé, ce qui peut prendre une minute.
Une notification s’affiche dans le portail une fois le service instance créé.
Cliquez sur la notification pour explorer votre nouveau service instance.
Cliquez sur le bouton Accéder à la ressource dans la notification pour explorer votre nouvelle instance de service. Vous serez redirigé vers votre nouvelle instance de service API Vision par ordinateur.
Dans ce tutoriel, votre application doit effectuer des appels à votre service, ce qui est effectué à l’aide de la clé d’abonnement de votre service.
Dans la page Démarrage rapide, de votre service API Vision par ordinateur, accédez à la première étape, Récupérer vos clés, puis cliquez sur Clés (vous pouvez également y parvenir en cliquant sur le lien hypertexte bleu Clés, situé dans le menu de navigation des services, indiqué par l’icône de clé). Cela révélera vos clés de service.
Prenez une copie de l’une des clés affichées, car vous en aurez besoin plus tard dans votre projet.
Retour à la page Démarrage rapide, puis récupérez votre point de terminaison. Sachez que le vôtre peut être différent, en fonction de votre région (ce qui, si c’est le cas, vous devrez apporter une modification à votre code ultérieurement). Prenez une copie de ce point de terminaison pour une utilisation ultérieure :
Conseil
Vous pouvez case activée les différents points de terminaison ici.
Chapitre 2 : Configurer le projet Unity
Ce qui suit est une configuration classique pour le développement avec la réalité mixte. En tant que tel, il s’agit d’un bon modèle pour d’autres projets.
Ouvrez Unity , puis cliquez sur Nouveau.
Vous devez maintenant fournir un nom de projet Unity. Insérez MR_ComputerVision. Vérifiez que le type de projet est défini sur 3D. Définissez l’emplacement sur un emplacement approprié pour vous (n’oubliez pas qu’il est préférable de se rapprocher des répertoires racine). Cliquez ensuite sur Créer un projet.
Une fois Unity ouvert, il est utile de vérifier que l’éditeur de script par défaut est défini sur Visual Studio. Accédez à Modifier les > préférences , puis, dans la nouvelle fenêtre, accédez à Outils externes. Remplacez Éditeur de script externe par Visual Studio 2017. Fermez la fenêtre Préférences.
Ensuite, accédez à Paramètres de build de fichier > et sélectionnez plateforme Windows universelle, puis cliquez sur le bouton Changer de plateforme pour appliquer votre sélection.
Toujours dans Paramètres de build de fichier > et assurez-vous que :
L’appareil cible est défini sur HoloLens
Pour les casques immersifs, définissez Appareil cible sur N’importe quel appareil.
Le type de build est défini sur D3D
Le KIT DE DÉVELOPPEMENT LOGICIEL (SDK) est défini sur Dernier installé
La version de Visual Studio est définie sur Dernière installation
Générer et exécuter est défini sur Ordinateur local
Enregistrez la scène et ajoutez-la à la build.
Pour ce faire, sélectionnez Ajouter des scènes ouvertes. Une fenêtre d’enregistrement s’affiche.
Créez un dossier pour cette scène et toute autre scène future, puis sélectionnez le bouton Nouveau dossier pour créer un dossier, nommez-le Scènes.
Ouvrez votre dossier Scenes nouvellement créé, puis dans le champ de texte Nom de fichier : , tapez MR_ComputerVisionScene, puis cliquez sur Enregistrer.
N’oubliez pas que vous devez enregistrer vos scènes Unity dans le dossier Assets , car elles doivent être associées au projet Unity. La création du dossier scenes (et d’autres dossiers similaires) est un moyen classique de structurer un projet Unity.
Les paramètres restants, dans Paramètres de build, doivent être conservés par défaut pour l’instant.
Dans la fenêtre Paramètres de build, cliquez sur le bouton Paramètres du lecteur pour ouvrir le panneau associé dans l’espace où se trouve l’inspecteur.
Dans ce panneau, quelques paramètres doivent être vérifiés :
Sous l’onglet Autres paramètres :
La version du runtime de script doit être stable (équivalent.NET 3.5).
Le serveur principal de script doit être .NET
Le niveau de compatibilité de l’API doit être .NET 4.6
Sous l’onglet Paramètres de publication, sous Fonctionnalités, case activée :
InternetClient
Webcam
Plus bas dans le panneau, dans Paramètres XR (situé sous Paramètres de publication), cochez Réalité virtuelle prise en charge, assurez-vous que le Kit de développement logiciel (SDK) Windows Mixed Reality est ajouté.
Retour dans Paramètres de buildUnity C# Projects n’est plus grisé ; cochez la case en regard de ceci.
Fermez la fenêtre Build Settings.
Enregistrez votre scène et votre projet (FILE > SAVE SCENE / FILE > SAVE PROJECT).
Chapitre 3 : Configuration de l’appareil photo principal
Important
Si vous souhaitez ignorer le composant Unity Set up de ce cours et continuer directement dans le code, n’hésitez pas à télécharger ce fichier .unitypackage, à l’importer dans votre projet en tant que package personnalisé, puis à continuer à partir du chapitre 5.
Dans le panneau Hiérarchie, sélectionnez la caméra principale.
Une fois cette option sélectionnée, vous pourrez voir tous les composants de la caméra principale dans le panneau de l’inspecteur.
L’objet Camera doit être nommé Main Camera (notez l’orthographe !)
La balise Main Camera doit être définie sur MainCamera (notez l’orthographe !)
Vérifiez que la position de transformation est définie sur 0, 0, 0
Définissez Clear Flags sur Couleur unie (ignorez cela pour le casque immersif).
Définissez la couleur d’arrière-plan du composant Caméra sur Noir, Alpha 0 (code hexadécimal : #00000000) (ignorez cette valeur pour le casque immersif).
Ensuite, vous devez créer un objet « Cursor » simple attaché à la caméra principale, qui vous aidera à positionner la sortie de l’analyse d’image lorsque l’application est en cours d’exécution. Ce curseur détermine le point central du focus de la caméra.
Pour créer le curseur :
Dans le panneau Hiérarchie, cliquez avec le bouton droit sur la caméra principale. Sous Objet 3D, cliquez sur Sphere.
Renommez la sphère en Curseur (double-cliquez sur l’objet Cursor ou appuyez sur le bouton clavier « F2 » avec l’objet sélectionné) et assurez-vous qu’il se trouve en tant qu’enfant de la caméra principale.
Dans le panneau Hiérarchie, cliquez avec le bouton gauche sur le curseur. Une fois le curseur sélectionné, ajustez les variables suivantes dans le panneau Inspecteur :
Définir la position de transformation sur 0, 0, 5
Définir l’échelle sur 0.02, 0.02, 0.02
Chapitre 4 : Configurer le système d’étiquettes
Une fois que vous avez capturé une image avec la caméra HoloLens, cette image est envoyée à votre instance service d’API Azure Vision par ordinateur à des fins d’analyse.
Les résultats de cette analyse seront une liste d’objets reconnus appelés Balises.
Vous utiliserez étiquettes (sous forme de texte 3D dans l’espace mondial) pour afficher ces étiquettes à l’emplacement où la photo a été prise.
Les étapes suivantes montrent comment configurer l’objet Label .
Cliquez avec le bouton droit n’importe où dans le panneau hiérarchie (l’emplacement n’a pas d’importance à ce stade), sous Objet 3D, ajoutez un texte 3D. Nommez-le LabelText.
Dans le panneau Hierarchy, cliquez avec le bouton gauche sur labelText. Avec l’option LabelText sélectionnée, ajustez les variables suivantes dans le panneau Inspector :
- Définissez position sur0,0,0
- Définissez l’échelle sur 0.01, 0.01, 0.01
- Dans le composant Text Mesh :
- Remplacez tout le texte dans Text par « ... »
- Définir l’ancre sur Centre central
- Définir l’alignement sur Centrer
- Définissez la taille de l’onglet sur 4
- Définir la taille de police sur 50
- Définissez la couleur sur #FFFFFFFF
Faites glisser le LabelText à partir du panneau Hierarchy, dans le dossier Asset, dans le panneau Project. Le LabelText est alors un prefab, afin qu’il puisse être instancié dans le code.
Vous devez supprimer le LabelText du panneau hierarchy afin qu’il ne s’affiche pas dans la scène d’ouverture. Comme il s’agit maintenant d’un préfabriqué, que vous allez appeler pour des instances individuelles à partir de votre dossier Assets, il n’est pas nécessaire de le conserver dans la scène.
La structure d’objet finale dans le panneau de hiérarchie doit être semblable à celle illustrée dans l’image ci-dessous :
Chapitre 5 – Créer la classe ResultsLabel
Le premier script que vous devez créer est la classe ResultsLabel , qui est responsable des éléments suivants :
- Création des étiquettes dans l’espace universel approprié, par rapport à la position de l’appareil photo.
- Affichage des balises de l’image Anaysis.
Pour créer cette classe :
Cliquez avec le bouton droit dans le volet Projet, puis sur Créer un > dossier. Nommez le dossier Scripts.
Avec le dossier Scripts créé, double-cliquez dessus pour l’ouvrir. Ensuite, dans ce dossier, cliquez avec le bouton droit, puis sélectionnez Créer > , puis Script C#. Nommez le script ResultsLabel.
Double-cliquez sur le nouveau script ResultsLabel pour l’ouvrir avec Visual Studio.
Dans la classe, insérez le code suivant dans la classe ResultsLabel :
using System.Collections.Generic; using UnityEngine; public class ResultsLabel : MonoBehaviour { public static ResultsLabel instance; public GameObject cursor; public Transform labelPrefab; [HideInInspector] public Transform lastLabelPlaced; [HideInInspector] public TextMesh lastLabelPlacedText; private void Awake() { // allows this instance to behave like a singleton instance = this; } /// <summary> /// Instantiate a Label in the appropriate location relative to the Main Camera. /// </summary> public void CreateLabel() { lastLabelPlaced = Instantiate(labelPrefab, cursor.transform.position, transform.rotation); lastLabelPlacedText = lastLabelPlaced.GetComponent<TextMesh>(); // Change the text of the label to show that has been placed // The final text will be set at a later stage lastLabelPlacedText.text = "Analysing..."; } /// <summary> /// Set the Tags as Text of the last Label created. /// </summary> public void SetTagsToLastLabel(Dictionary<string, float> tagsDictionary) { lastLabelPlacedText = lastLabelPlaced.GetComponent<TextMesh>(); // At this point we go through all the tags received and set them as text of the label lastLabelPlacedText.text = "I see: \n"; foreach (KeyValuePair<string, float> tag in tagsDictionary) { lastLabelPlacedText.text += tag.Key + ", Confidence: " + tag.Value.ToString("0.00 \n"); } } }Veillez à enregistrer vos modifications dans Visual Studio avant de revenir à Unity.
De retour dans l’éditeur Unity, cliquez et faites glisser la classe ResultsLabel du dossier Scripts vers l’objet Main Camera dans le panneau Hierarchy.
Cliquez sur la caméra principale et regardez le panneau d’inspecteur.
Vous remarquerez que dans le script que vous venez de faire glisser dans l’appareil photo, il existe deux champs : Cursor et Label Prefab.
Faites glisser l’objet appelé Cursor du panneau de hiérarchie vers l’emplacement nommé Cursor, comme illustré dans l’image ci-dessous.
Faites glisser l’objet appelé LabelText du dossier Assets dans le panneau de projet vers l’emplacement nommé Label Prefab, comme illustré dans l’image ci-dessous.
Chapitre 6 : Créer la classe ImageCapture
La classe suivante que vous allez créer est la classe ImageCapture . Cette classe est responsable des opérations suivantes :
- Capture d’une image à l’aide de l’appareil photo HoloLens et stockage dans le dossier d’application.
- Capture des mouvements d’appui de l’utilisateur.
Pour créer cette classe :
Accédez au dossier Scripts que vous avez créé précédemment.
Cliquez avec le bouton droit dans le dossier Créer un > script C#. Appelez le script ImageCapture.
Double-cliquez sur le nouveau script ImageCapture pour l’ouvrir avec Visual Studio.
Ajoutez les espaces de noms suivants en haut du fichier :
using System.IO; using System.Linq; using UnityEngine; using UnityEngine.XR.WSA.Input; using UnityEngine.XR.WSA.WebCam;Ajoutez ensuite les variables suivantes dans la classe ImageCapture , au-dessus de la méthode Start() :
public static ImageCapture instance; public int tapsCount; private PhotoCapture photoCaptureObject = null; private GestureRecognizer recognizer; private bool currentlyCapturing = false;
La variable tapsCount stocke le nombre de mouvements d’appui capturés auprès de l’utilisateur. Ce nombre est utilisé dans le nommage des images capturées.
Le code pour les méthodes Awake() et Start() doit maintenant être ajouté. Celles-ci sont appelées lorsque la classe initialise :
private void Awake() { // Allows this instance to behave like a singleton instance = this; } void Start() { // subscribing to the HoloLens API gesture recognizer to track user gestures recognizer = new GestureRecognizer(); recognizer.SetRecognizableGestures(GestureSettings.Tap); recognizer.Tapped += TapHandler; recognizer.StartCapturingGestures(); }Implémentez un gestionnaire qui sera appelé lorsqu’un mouvement d’appui se produit.
/// <summary> /// Respond to Tap Input. /// </summary> private void TapHandler(TappedEventArgs obj) { // Only allow capturing, if not currently processing a request. if(currentlyCapturing == false) { currentlyCapturing = true; // increment taps count, used to name images when saving tapsCount++; // Create a label in world space using the ResultsLabel class ResultsLabel.instance.CreateLabel(); // Begins the image capture and analysis procedure ExecuteImageCaptureAndAnalysis(); } }
La méthode TapHandler() incrémente le nombre d’appuis capturés auprès de l’utilisateur et utilise la position actuelle du curseur pour déterminer où placer une nouvelle étiquette.
Cette méthode appelle ensuite la méthode ExecuteImageCaptureAndAnalysis() pour commencer les fonctionnalités principales de cette application.
Une fois qu’une image a été capturée et stockée, les gestionnaires suivants sont appelés. Si le processus réussit, le résultat est passé à VisionManager (que vous n’avez pas encore créé) à des fins d’analyse.
/// <summary> /// Register the full execution of the Photo Capture. If successful, it will begin /// the Image Analysis process. /// </summary> void OnCapturedPhotoToDisk(PhotoCapture.PhotoCaptureResult result) { // Call StopPhotoMode once the image has successfully captured photoCaptureObject.StopPhotoModeAsync(OnStoppedPhotoMode); } void OnStoppedPhotoMode(PhotoCapture.PhotoCaptureResult result) { // Dispose from the object in memory and request the image analysis // to the VisionManager class photoCaptureObject.Dispose(); photoCaptureObject = null; StartCoroutine(VisionManager.instance.AnalyseLastImageCaptured()); }Ajoutez ensuite la méthode que l’application utilise pour démarrer le processus de capture d’image et stocker l’image.
/// <summary> /// Begin process of Image Capturing and send To Azure /// Computer Vision service. /// </summary> private void ExecuteImageCaptureAndAnalysis() { // Set the camera resolution to be the highest possible Resolution cameraResolution = PhotoCapture.SupportedResolutions.OrderByDescending((res) => res.width * res.height).First(); Texture2D targetTexture = new Texture2D(cameraResolution.width, cameraResolution.height); // Begin capture process, set the image format PhotoCapture.CreateAsync(false, delegate (PhotoCapture captureObject) { photoCaptureObject = captureObject; CameraParameters camParameters = new CameraParameters(); camParameters.hologramOpacity = 0.0f; camParameters.cameraResolutionWidth = targetTexture.width; camParameters.cameraResolutionHeight = targetTexture.height; camParameters.pixelFormat = CapturePixelFormat.BGRA32; // Capture the image from the camera and save it in the App internal folder captureObject.StartPhotoModeAsync(camParameters, delegate (PhotoCapture.PhotoCaptureResult result) { string filename = string.Format(@"CapturedImage{0}.jpg", tapsCount); string filePath = Path.Combine(Application.persistentDataPath, filename); VisionManager.instance.imagePath = filePath; photoCaptureObject.TakePhotoAsync(filePath, PhotoCaptureFileOutputFormat.JPG, OnCapturedPhotoToDisk); currentlyCapturing = false; }); }); }
Avertissement
À ce stade, vous remarquerez qu’une erreur s’affiche dans le panneau de console de l’éditeur Unity. En effet, le code fait référence à la classe VisionManager que vous allez créer dans le chapitre suivant.
Chapitre 7 : Appel à Azure et analyse d’images
Le dernier script que vous devez créer est la classe VisionManager .
Cette classe est responsable des opérations suivantes :
- Chargement de la dernière image capturée sous la forme d’un tableau d’octets.
- Envoi du tableau d’octets à votre instance service d’API Azure Vision par ordinateur à des fins d’analyse.
- Réception de la réponse sous forme de chaîne JSON.
- Désérialisation de la réponse et transmission des balises obtenues à la classe ResultsLabel .
Pour créer cette classe :
Double-cliquez sur le dossier Scripts pour l’ouvrir.
Cliquez avec le bouton droit dans le dossier Scripts , puis cliquez sur Créer un > script C#. Nommez le script VisionManager.
Double-cliquez sur le nouveau script pour l’ouvrir avec Visual Studio.
Mettez à jour les espaces de noms pour qu’ils soient identiques à ce qui suit, en haut de la classe VisionManager :
using System; using System.Collections; using System.Collections.Generic; using System.IO; using UnityEngine; using UnityEngine.Networking;En haut de votre script, à l’intérieur de la classe VisionManager (au-dessus de la méthode Start(), vous devez maintenant créer deux classes qui représenteront la réponse JSON désérialisée d’Azure :
[System.Serializable] public class TagData { public string name; public float confidence; } [System.Serializable] public class AnalysedObject { public TagData[] tags; public string requestId; public object metadata; }Notes
L’attribut [System.Serializable] des classes TagData et AnalysedObject doit être ajouté avant la déclaration pour pouvoir être désérialisé avec les bibliothèques Unity.
Dans la classe VisionManager, vous devez ajouter les variables suivantes :
public static VisionManager instance; // you must insert your service key here! private string authorizationKey = "- Insert your key here -"; private const string ocpApimSubscriptionKeyHeader = "Ocp-Apim-Subscription-Key"; private string visionAnalysisEndpoint = "https://westus.api.cognitive.microsoft.com/vision/v1.0/analyze?visualFeatures=Tags"; // This is where you need to update your endpoint, if you set your location to something other than west-us. internal byte[] imageBytes; internal string imagePath;Avertissement
Veillez à insérer votre clé d’authentification dans la variable authorizationKey . Vous aurez noté votre clé d’authentification au début de ce cours, Chapitre 1.
Avertissement
La variable visionAnalysisEndpoint peut différer de celle spécifiée dans cet exemple. L’usa ouest fait strictement référence aux instances de service créées pour la région USA Ouest. Mettez-le à jour avec l’URL de votre point de terminaison ; Voici quelques exemples de ce à quoi cela peut ressembler :
- Europe Ouest :
https://westeurope.api.cognitive.microsoft.com/vision/v1.0/analyze?visualFeatures=Tags - Asie Sud-Est :
https://southeastasia.api.cognitive.microsoft.com/vision/v1.0/analyze?visualFeatures=Tags - Australie Est :
https://australiaeast.api.cognitive.microsoft.com/vision/v1.0/analyze?visualFeatures=Tags
- Europe Ouest :
Le code pour Awake doit maintenant être ajouté.
private void Awake() { // allows this instance to behave like a singleton instance = this; }Ensuite, ajoutez la coroutine (avec la méthode de flux statique en dessous), qui obtiendra les résultats de l’analyse de l’image capturée par la classe ImageCapture .
/// <summary> /// Call the Computer Vision Service to submit the image. /// </summary> public IEnumerator AnalyseLastImageCaptured() { WWWForm webForm = new WWWForm(); using (UnityWebRequest unityWebRequest = UnityWebRequest.Post(visionAnalysisEndpoint, webForm)) { // gets a byte array out of the saved image imageBytes = GetImageAsByteArray(imagePath); unityWebRequest.SetRequestHeader("Content-Type", "application/octet-stream"); unityWebRequest.SetRequestHeader(ocpApimSubscriptionKeyHeader, authorizationKey); // the download handler will help receiving the analysis from Azure unityWebRequest.downloadHandler = new DownloadHandlerBuffer(); // the upload handler will help uploading the byte array with the request unityWebRequest.uploadHandler = new UploadHandlerRaw(imageBytes); unityWebRequest.uploadHandler.contentType = "application/octet-stream"; yield return unityWebRequest.SendWebRequest(); long responseCode = unityWebRequest.responseCode; try { string jsonResponse = null; jsonResponse = unityWebRequest.downloadHandler.text; // The response will be in Json format // therefore it needs to be deserialized into the classes AnalysedObject and TagData AnalysedObject analysedObject = new AnalysedObject(); analysedObject = JsonUtility.FromJson<AnalysedObject>(jsonResponse); if (analysedObject.tags == null) { Debug.Log("analysedObject.tagData is null"); } else { Dictionary<string, float> tagsDictionary = new Dictionary<string, float>(); foreach (TagData td in analysedObject.tags) { TagData tag = td as TagData; tagsDictionary.Add(tag.name, tag.confidence); } ResultsLabel.instance.SetTagsToLastLabel(tagsDictionary); } } catch (Exception exception) { Debug.Log("Json exception.Message: " + exception.Message); } yield return null; } }/// <summary> /// Returns the contents of the specified file as a byte array. /// </summary> private static byte[] GetImageAsByteArray(string imageFilePath) { FileStream fileStream = new FileStream(imageFilePath, FileMode.Open, FileAccess.Read); BinaryReader binaryReader = new BinaryReader(fileStream); return binaryReader.ReadBytes((int)fileStream.Length); }Veillez à enregistrer vos modifications dans Visual Studio avant de revenir à Unity.
De retour dans l’éditeur Unity, cliquez et faites glisser les classes VisionManager et ImageCapture du dossier Scripts vers l’objet Main Camera dans le panneau hierarchy.
Chapitre 8 – Avant de créer
Pour effectuer un test approfondi de votre application, vous devez la charger de manière indépendante sur votre HoloLens. Avant de le faire, assurez-vous que :
- Tous les paramètres mentionnés dans le chapitre 2 sont correctement définis.
- Tous les scripts sont attachés à l’objet Main Camera .
- Tous les champs du panneau principal de l’inspecteur de la caméra sont attribués correctement.
- Veillez à insérer votre clé d’authentification dans la variable authorizationKey .
- Vérifiez que vous avez également vérifié votre point de terminaison dans votre script VisionManager et qu’il s’aligne sur votre région (ce document utilise la région ouest par défaut).
Chapitre 9 : Générer la solution UWP et charger une version test de l’application
Tout ce qui est nécessaire pour la section Unity de ce projet est maintenant terminé. Il est donc temps de le générer à partir d’Unity.
Accédez à Paramètres - de buildParamètres du fichier > Paramètres de build...
Dans la fenêtre Paramètres de build, cliquez sur Générer.
Si ce n’est pas déjà le cas, cochez Projets Unity C#.
Cliquez sur Générer. Unity lance une fenêtre Explorateur de fichiers, dans laquelle vous devez créer, puis sélectionner un dossier dans lequel générer l’application. Créez ce dossier maintenant et nommez-le Application. Ensuite, avec le dossier Application sélectionné, appuyez sur Sélectionner un dossier.
Unity commence à générer votre projet dans le dossier Application .
Une fois la génération terminée (cela peut prendre un certain temps), Unity ouvre une fenêtre Explorateur de fichiers à l’emplacement de votre build (case activée votre barre des tâches, car elle n’apparaît peut-être pas toujours au-dessus de vos fenêtres, mais vous informe de l’ajout d’une nouvelle fenêtre).
Chapitre 10 : Déployer sur HoloLens
Pour déployer sur HoloLens :
Vous aurez besoin de l’adresse IP de votre HoloLens (pour le déploiement à distance) et de vous assurer que votre HoloLens est en mode développeur. Pour ce faire :
- Lorsque vous portez votre HoloLens, ouvrez les Paramètres.
- Accédez à Network & Internet > Wi-Fi > Advanced Options
- Notez l’adresse IPv4 .
- Ensuite, revenez à Paramètres, puis à Mettre à jour & sécurité > pour les développeurs
- Définissez Mode développeur activé.
Accédez à votre nouvelle build Unity (le dossier App ) et ouvrez le fichier solution avec Visual Studio.
Dans configuration de la solution, sélectionnez Déboguer.
Dans Plateforme de solution, sélectionnez x86, Ordinateur distant.
Accédez au menu Générer et cliquez sur Déployer la solution pour charger l’application sur votre HoloLens.
Votre application doit maintenant apparaître dans la liste des applications installées sur votre HoloLens, prête à être lancée !
Notes
Pour effectuer un déploiement sur un casque immersif, définissez La plateforme de solution sur Ordinateur local et définissez la configuration sur Déboguer, avec x86 comme plateforme. Déployez ensuite sur l’ordinateur local, à l’aide du menu Générer, en sélectionnant Déployer la solution.
Votre application API Vision par ordinateur terminée
Félicitations, vous avez créé une application de réalité mixte qui tire parti de l’API Azure Vision par ordinateur pour reconnaître des objets réels et afficher la confiance de ce qui a été vu.
Exercices bonus
Exercice 1
Tout comme vous avez utilisé le paramètre Tags (comme indiqué dans le point de terminaison utilisé dans VisionManager), étendez l’application pour détecter d’autres informations ; jetez un coup d’œil aux autres paramètres que vous avez accès ici.
Exercice 2
Affichez les données Azure retournées, de manière plus conversationnelle et lisible, en masquant peut-être les nombres. Comme si un bot pouvait parler à l’utilisateur.