HoloLens (1. Generation) und Azure 302: Computer vision

Artikel
07/04/2024

Hinweis

Die Tutorials der Mixed Reality Academy wurden im Hinblick auf HoloLens (1. Gen.) und immersive Mixed Reality-Headsets entworfen. Daher halten wir es für wichtig, diese Tutorials für Entwickler verfügbar zu halten, die noch nach Anleitung beim Entwickeln für diese Geräte suchen. Diese Tutorials werden nicht mit den neuesten Toolsets oder Interaktionen aktualisiert, die für HoloLens 2 verwendet werden. Sie werden gewartet, um weiterhin auf den unterstützten Geräten zu funktionieren. Es wird eine neue Reihe von Lernprogrammen geben, die in Zukunft veröffentlicht werden, die zeigen, wie sie für HoloLens 2 entwickelt werden. Dieser Hinweis wird mit einem Link zu diesen Lernprogrammen aktualisiert, wenn sie veröffentlicht werden.

In diesem Kurs erfahren Sie, wie Sie visuelle Inhalte in einem bereitgestellten Bild mithilfe von Azure maschinelles Sehen-Funktionen in einer Mixed Reality-Anwendung erkennen.

Erkennungsergebnisse werden als beschreibende Tags angezeigt. Sie können diesen Dienst verwenden, ohne ein Machine Learning-Modell trainieren zu müssen. Wenn Ihre Implementierung schulungen für ein Machine Learning-Modell erfordert, lesen Sie MR und Azure 302b.

Lab-Ergebnis

Microsoft maschinelles Sehen ist eine Reihe von APIs, die Entwicklern Bildverarbeitung und Analyse (mit Rückgabeinformationen) mit erweiterten Algorithmen aus der Cloud bereitstellen. Entwickler laden eine Bild- oder Bild-URL hoch, und die Microsoft maschinelles Sehen-API-Algorithmen analysieren den visuellen Inhalt, basierend auf eingaben, die den Benutzer ausgewählt haben, die Informationen zurückgeben können, einschließlich der Identifizierung des Typs und der Qualität eines Bilds, Erkennen von menschlichen Gesichtern (Zurückgeben ihrer Koordinaten) und Kategorisieren von Bildern oder Kategorisieren von Bildern. Weitere Informationen finden Sie auf der Seite "Azure maschinelles Sehen-API".

Nachdem Sie diesen Kurs abgeschlossen haben, haben Sie eine Mixed Reality HoloLens-Anwendung, die folgende Aktionen ausführen kann:

Mit der Tippbewegung erfasst die Kamera der HoloLens ein Bild.
Das Bild wird an den Azure maschinelles Sehen-API-Dienst gesendet.
Die erkannten Objekte werden in einer einfachen Ui-Gruppe aufgelistet, die in der Unity-Szene positioniert ist.

In Ihrer Anwendung liegt es an Ihnen, wie Sie die Ergebnisse in Ihr Design integrieren. Dieser Kurs soll Ihnen vermitteln, wie Sie einen Azure Service in Ihr Unity-Projekt integrieren. Es ist Ihre Aufgabe, das Wissen zu nutzen, das Sie aus diesem Kurs gewinnen, um Ihre Mixed Reality-Anwendung zu verbessern.

Unterstützung für Geräte

Kurs	HoloLens	Immersive Headsets
MR und Azure 302: Computer vision	✔️	✔️

Hinweis

Während sich dieser Kurs hauptsächlich auf HoloLens konzentriert, können Sie auch das, was Sie in diesem Kurs lernen, auf Windows Mixed Reality immersive Headsets (VR) anwenden. Da immersive Headsets (VR) keine barrierefreien Kameras haben, benötigen Sie eine externe Kamera, die mit Ihrem PC verbunden ist. Während Sie den Kurs befolgen, werden Notizen zu allen Änderungen angezeigt, die Sie möglicherweise verwenden müssen, um immersive Headsets (VR) zu unterstützen.

Voraussetzungen

Hinweis

Dieses Lernprogramm wurde für Entwickler entwickelt, die grundlegende Erfahrung mit Unity und C# haben. Bitte beachten Sie auch, dass die Voraussetzungen und schriftlichen Anweisungen in diesem Dokument das zum Zeitpunkt der Schriftlichkeit (Mai 2018) getestet und überprüft wurden. Sie sind kostenlos, die neueste Software zu verwenden, wie im Artikel "Tools installieren" aufgeführt, aber es sollte nicht angenommen werden, dass die Informationen in diesem Kurs perfekt mit dem übereinstimmen, was Sie in neuerer Software finden als die unten aufgeführten.

Wir empfehlen die folgende Hardware und Software für diesen Kurs:

Ein Entwicklungs-PC, kompatibel mit Windows Mixed Reality für die Entwicklung von immersiven (VR)-Headsets
Windows 10 Fall Creators Update (oder höher) mit aktivierter Entwicklermodus
Das neueste Windows 10 SDK
Unity 2017.4
Visual Studio 2017
Ein immersives Windows Mixed Reality-Headset (VR) oder Microsoft HoloLens mit aktiviertem Entwicklermodus
Eine Kamera, die an Ihren PC angeschlossen ist (für die entwicklung immersive Headsets)
Internetzugriff für Azure-Setup und maschinelles Sehen API-Abruf

Vor der Installation

Um Probleme beim Erstellen dieses Projekts zu vermeiden, wird dringend empfohlen, das in diesem Lernprogramm erwähnte Projekt in einem Stamm- oder Near-Root-Ordner zu erstellen (lange Ordnerpfade können zu Buildzeit zu Problemen führen).
Richten Sie Ihre HoloLens ein, und testen Sie sie. Wenn Sie Unterstützung beim Einrichten Ihrer HoloLens benötigen, besuchen Sie den HoloLens-Setupartikel.
Es empfiehlt sich, beim Entwickeln einer neuen HoloLens-App Kalibrierung und Sensoroptimierung durchzuführen (manchmal kann es hilfreich sein, diese Aufgaben für jeden Benutzer auszuführen).

Hilfe zur Kalibrierung finden Sie unter diesem Link zum HoloLens-Kalibrierungsartikel.

Hilfe zur Sensoroptimierung finden Sie in diesem Link zum Artikel "HoloLens Sensor Tuning".

Kapitel 1 – Das Azure-Portal

Um den maschinelles Sehen-API-Dienst in Azure zu verwenden, müssen Sie eine Instanz des Diensts konfigurieren, die Ihrer Anwendung zur Verfügung gestellt werden soll.

Melden Sie sich zuerst beim Azure-Portal an.

Hinweis

Wenn Sie noch nicht über ein Azure-Konto verfügen, müssen Sie ein Konto erstellen. Wenn Sie diesem Lernprogramm in einer Unterrichts- oder Laborsituation folgen, bitten Sie Ihren Kursleiter oder einen der Betreuer, Hilfe beim Einrichten Ihres neuen Kontos zu erhalten.
Nachdem Sie angemeldet sind, klicken Sie in der oberen linken Ecke auf "Neu", und suchen Sie nach maschinelles Sehen API, und klicken Sie auf EINGABETASTE.

Hinweis

Das Wort "Neu" wurde möglicherweise durch "Ressource erstellen" in neueren Portalen ersetzt.
Die neue Seite enthält eine Beschreibung des maschinelles Sehen-API-Diensts. Wählen Sie unten links auf dieser Seite die Schaltfläche "Erstellen " aus, um eine Zuordnung zu diesem Dienst zu erstellen.
Nachdem Sie auf "Erstellen" geklickt haben:
1. Fügen Sie ihren gewünschten Namen für diese Dienstinstanz ein.
2. Wählen Sie ein Abonnementaus.
3. Wählen Sie die für Sie geeignete Preisstufe aus, wenn Sie zum ersten Mal einen maschinelles Sehen-API-Dienst erstellen, sollte ihnen eine kostenlose Stufe (mit dem Namen F0) zur Verfügung stehen.
4. Wählen Sie eine Ressourcengruppe aus, oder erstellen Sie eine neue. Eine Ressourcengruppe bietet eine Möglichkeit, die Abrechnung für eine Sammlung von Azure-Ressourcen zu überwachen, zu steuern, den Zugriff zu steuern, bereitzustellen und zu verwalten. Es wird empfohlen, alle Azure-Dienste, die einem einzelnen Projekt (z. B. diesen Laboren) zugeordnet sind, unter einer gemeinsamen Ressourcengruppe zu halten.
  
  Wenn Sie mehr über Azure-Ressourcengruppen erfahren möchten, besuchen Sie bitte den Artikel zur Ressourcengruppe.
5. Bestimmen Sie den Speicherort für Ihre Ressourcengruppe (wenn Sie eine neue Ressourcengruppe erstellen). Der Standort wäre idealerweise in der Region, in der die Anwendung ausgeführt würde. Einige Azure-Ressourcen sind nur in bestimmten Regionen verfügbar.
6. Sie müssen auch bestätigen, dass Sie die auf diesen Dienst angewendeten Allgemeinen Geschäftsbedingungen verstanden haben.
7. Klicken Sie auf Erstellen.
Nachdem Sie auf "Erstellen" geklickt haben, müssen Sie warten, bis der Dienst erstellt wurde. Dies kann eine Minute dauern.
Sobald die Dienstinstanz erstellt wurde, wird im Portal eine Benachrichtigung angezeigt.
Klicken Sie auf die Benachrichtigung, um Ihre neue Dienstinstanz zu erkunden.
Klicken Sie in der Benachrichtigung auf die Schaltfläche "Zur Ressource wechseln", um Ihre neue Dienstinstanz zu erkunden. Sie werden zu Ihrer neuen maschinelles Sehen API-Dienstinstanz weitergeleitet.
In diesem Lernprogramm muss Ihre Anwendung Aufrufe an Ihren Dienst tätigen, was über den Abonnementschlüssel Ihres Diensts erfolgt.
Navigieren Sie auf der Schnellstartseite Ihres maschinelles Sehen-API-Diensts zum ersten Schritt, greifen Sie Ihre Schlüssel ab, und klicken Sie auf "Schlüssel" (Sie können dies auch erreichen, indem Sie auf die blauen Hyperlinkschlüssel klicken, die sich im Navigationsmenü der Dienste befinden, das durch das Schlüsselsymbol gekennzeichnet ist). Dadurch werden Ihre Dienstschlüssel angezeigt.
Erstellen Sie eine Kopie einer der angezeigten Schlüssel, da Sie dies später in Ihrem Projekt benötigen.
Wechseln Sie zurück zur Schnellstartseite , und rufen Sie dort Ihren Endpunkt ab. Beachten Sie, dass Ihre Einstellungen je nach Region unterschiedlich sind (was in diesem Beispiel der Grund ist, müssen Sie später eine Änderung an Ihrem Code vornehmen). Erstellen Sie eine Kopie dieses Endpunkts für die spätere Verwendung:

Tipp

Sie können überprüfen, was die verschiedenen Endpunkte HIER sind.

Kapitel 2 – Einrichten des Unity-Projekts

Im Folgenden sehen Sie eine typische Einrichtung für die Entwicklung mit Mixed Reality und ist daher eine gute Vorlage für andere Projekte.

Öffnen Sie Unity , und klicken Sie auf "Neu".
Sie müssen nun einen Unity-Projektnamen angeben. Fügen Sie MR_ComputerVision ein. Stellen Sie sicher, dass der Projekttyp auf 3D festgelegt ist. Legen Sie den Speicherort an einer für Sie geeigneten Stelle fest (denken Sie daran, dass die Stammverzeichnisse besser sind). Klicken Sie dann auf "Projekt erstellen".
Wenn Unity geöffnet ist, lohnt es sich, den Standardmäßigen Skript-Editor auf Visual Studio festzulegen. Wechseln Sie zu "Einstellungen bearbeiten>", und navigieren Sie dann im neuen Fenster zu "Externe Tools". Ändern Sie den externen Skript-Editor in Visual Studio 2017. Schließen Sie das Fenster Einstellungen.
Wechseln Sie als Nächstes zu "Dateibuildeinstellungen>", und wählen Sie Universelle Windows-Plattform aus, und klicken Sie dann auf die Schaltfläche "Plattform wechseln", um Ihre Auswahl anzuwenden.
Während Sie sich noch in den Dateibuildeinstellungen > befinden , und stellen Sie sicher, dass:
1. Zielgerät ist auf HoloLens festgelegt
  
  Legen Sie für die immersiven Headsets "Zielgerät " auf "Jedes Gerät" fest.
2. Buildtyp ist auf D3D festgelegt
3. SDK ist auf "Neueste Installation" festgelegt.
4. Visual Studio-Version ist auf "Neueste Installation" festgelegt.
5. Build und Ausführung ist auf den lokalen Computer festgelegt.
6. Speichern Sie die Szene, und fügen Sie sie dem Build hinzu.
  1. Wählen Sie dazu "Offene Szenen hinzufügen" aus. Ein Speicherfenster wird angezeigt.
  2. Erstellen Sie einen neuen Ordner für diese Und jede zukünftige Szene, und wählen Sie dann die Schaltfläche "Neuer Ordner " aus, um einen neuen Ordner zu erstellen, nennen Sie ihn "Szenen".
  3. Öffnen Sie den neu erstellten Ordner "Szenen", und klicken Sie dann im Feld "Dateiname": "Textfeld", geben Sie MR_ComputerVisionScene ein, und klicken Sie dann auf "Speichern".
    
    Beachten Sie, dass Sie Ihre Unity-Szenen im Ordner "Assets " speichern müssen, da sie dem Unity-Projekt zugeordnet sein müssen. Das Erstellen des Szenenordners (und andere ähnliche Ordner) ist eine typische Methode zum Strukturieren eines Unity-Projekts.
7. Die übrigen Einstellungen in den Buildeinstellungen sollten jetzt als Standard beibehalten werden.
Klicken Sie im Fenster "Buildeinstellungen " auf die Schaltfläche "Spielereinstellungen ". Dadurch wird der zugehörige Bereich im Bereich geöffnet, in dem sich der Inspektor befindet.
In diesem Bereich müssen einige Einstellungen überprüft werden:
1. Auf der Registerkarte "Andere Einstellungen" folgendes:
  1. Skripting Runtime-Version sollte stabil sein (.NET 3.5-Entsprechung).
  2. Scripting Back-End sollte .NET sein
  3. API-Kompatibilitätsstufe sollte .NET 4.6 sein
2. Aktivieren Sie auf der Registerkarte "Veröffentlichungseinstellungen " unter "Funktionen" Folgendes:
  1. InternetClient
  2. Webcam
3. Klicken Sie weiter unten im Bereich unter "XR-Einstellungen" (unter "Veröffentlichungseinstellungen" finden Sie auf "Virtual Reality Unterstützt"), und vergewissern Sie sich, dass das Windows Mixed Reality SDK hinzugefügt wird.
Zurück in Buildeinstellungen Unity C# -Projekte ist nicht mehr abgeblentet. Aktivieren Sie das Kontrollkästchen neben diesem.
Schließen Sie das Fenster Buildeinstellungen.
Speichern Sie Ihre Szene und Ihr Projekt (FILE > SAVE SCENE / FILE > SAVE PROJECT).

Kapitel 3 – Einrichtung der Hauptkamera

Wichtig

Wenn Sie die Unity Set up-Komponente dieses Kurses überspringen und direkt mit Code fortfahren möchten, können Sie dieses Unitypackage herunterladen, es als benutzerdefiniertes Paket in Ihr Projekt importieren und dann von Kapitel 5 fortfahren.

Wählen Sie im Hierarchiebereich die Hauptkamera aus.
Nach der Auswahl können Sie alle Komponenten der Hauptkamera im Inspektorbereich anzeigen.
1. Das Camera-Objekt muss die Hauptkamera genannt werden (beachten Sie die Schreibweise!)
2. Das Hauptkameratag muss auf "MainCamera" festgelegt werden (beachten Sie die Schreibweise!)
3. Stellen Sie sicher, dass die Transformationsposition auf 0, 0, 0 festgelegt ist.
4. Legen Sie "Flags löschen" auf "Volltonfarbe" fest (dies wird für immersives Headset ignoriert).
5. Legen Sie die Hintergrundfarbe der Kamerakomponente auf Schwarz, Alpha 0 (Hex-Code: #00000000) fest (ignorieren Sie dies für immersives Headset).
Als Nächstes müssen Sie ein einfaches "Cursor"-Objekt erstellen, das an die Hauptkamera angefügt ist, wodurch Sie die Bildanalyseausgabe positionieren können, wenn die Anwendung ausgeführt wird. Dieser Cursor bestimmt den Mittelpunkt des Kamerafokus.

So erstellen Sie den Cursor:

Klicken Sie im Hierarchiebereich mit der rechten Maustaste auf die Hauptkamera. Klicken Sie unter 3D-Objekt auf Kugel.
Benennen Sie die Kugel in den Cursor um (doppelklicken Sie auf das Cursorobjekt, oder drücken Sie die Tastenkombination "F2", und stellen Sie sicher, dass sie als untergeordnetes Element der Hauptkamera gespeichert ist.
Klicken Sie im Hierarchiebereich mit der linken Maustaste auf den Cursor. Wenn der Cursor ausgewählt ist, passen Sie die folgenden Variablen im Inspektorbereich an:
1. Festlegen der Transformationsposition auf 0, 0, 5
2. Festlegen der Skalierung auf 0,02, 0,02, 0,02

Kapitel 4 – Einrichten des Bezeichnungssystems

Nachdem Sie ein Bild mit der HoloLens-Kamera aufgenommen haben, wird dieses Bild zur Analyse an Ihre Azure maschinelles Sehen API Service-Instanz gesendet.

Die Ergebnisse dieser Analyse sind eine Liste der erkannten Objekte namens Tags.

Sie verwenden Bezeichnungen (als 3D-Text im Weltbereich), um diese Tags an der Position anzuzeigen, an der das Foto aufgenommen wurde.

Die folgenden Schritte zeigen, wie das Label-Objekt eingerichtet wird.

Klicken Sie mit der rechten Maustaste auf eine beliebige Stelle im Hierarchiebereich (die Position spielt an diesem Punkt keine Rolle), fügen Sie unter 3D-Objekt einen 3D-Text hinzu. Nennen Sie ihn "LabelText".
Klicken Sie im Hierarchiebereich mit der linken Maustaste auf den LabelText. Wenn " LabelText " ausgewählt ist, passen Sie die folgenden Variablen im Inspektorbereich an:
1. Festlegen der Position auf 0,0,0
2. Festlegen der Skalierung auf 0,01, 0,01, 0,01
3. In der Komponente Textgitter:
4. Ersetzen Sie den gesamten Text im Text durch "..."
5. Festlegen des Ankers auf mittlere Mitte
6. Festlegen der Ausrichtung auf Zentrierung
7. Festlegen der Registerkartengröße auf 4
8. Schriftgrad auf 50 festlegen
9. Festlegen der Farbe auf #FFFFFFFF
Ziehen Sie den LabelText aus dem Hierarchiebereich in den Objektordner im Projektbereich. Dadurch wird der LabelText als Prefab bezeichnet, sodass er im Code instanziiert werden kann.
Sie sollten den LabelText aus dem Hierarchiebereich löschen, damit er nicht in der öffnenden Szene angezeigt wird. Da es sich jetzt um ein Prefab handelt, das Sie für einzelne Instanzen aus Ihrem Ordner "Assets" aufrufen, muss sie nicht innerhalb der Szene beibehalten werden.
Die endgültige Objektstruktur im Hierarchiebereich sollte wie in der abbildung unten dargestellten sein:

Kapitel 5 – Erstellen der ResultsLabel-Klasse

Das erste Skript, das Sie erstellen müssen, ist die ResultsLabel-Klasse , die für Folgendes verantwortlich ist:

Erstellen der Beschriftungen im entsprechenden Raum der Welt relativ zur Position der Kamera.
Anzeigen der Tags aus der Bild-Anaysis.

So erstellen Sie diese Klasse:

Klicken Sie mit der rechten Maustaste in den Projektbereich, und erstellen Sie > dann den Ordner. Benennen Sie den Ordner Skripts.
Doppelklicken Sie beim Erstellen des Ordners "Skripts " darauf, um ihn zu öffnen. Klicken Sie dann in diesem Ordner mit der rechten Maustaste, und wählen Sie dann "C#-Skript erstellen>" aus. Nennen Sie das Skript ResultsLabel.
Doppelklicken Sie auf das neue ResultsLabel-Skript , um es mit Visual Studio zu öffnen.

Fügen Sie in der Klasse den folgenden Code in die ResultsLabel-Klasse ein:

    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");
            }    
        }
    }

Achten Sie darauf, ihre Änderungen in Visual Studio zu speichern, bevor Sie zu Unity zurückkehren.
Klicken Sie zurück im Unity-Editor, und ziehen Sie die ResultsLabel-Klasse aus dem Ordner "Skripts " in das Hauptkameraobjekt im Hierarchiebereich.
Klicken Sie auf die Hauptkamera , und sehen Sie sich den Inspektorbereich an.

Sie werden feststellen, dass aus dem Skript, das Sie gerade in die Kamera gezogen haben, zwei Felder vorhanden sind: Cursor und Label Prefab.

Ziehen Sie das Objekt namens "Cursor" aus dem Hierarchiebereich auf den Platz mit dem Namen "Cursor", wie in der abbildung unten dargestellt.
Ziehen Sie das Objekt mit dem Namen "LabelText " aus dem Ordner "Objekte" im Projektbereich auf den Platz " Label Prefab", wie in der abbildung unten dargestellt.

Kapitel 6 – Erstellen der ImageCapture-Klasse

Die nächste Klasse, die Sie erstellen werden, ist die ImageCapture-Klasse . Diese Klasse ist für Folgendes verantwortlich:

Aufnehmen eines Bilds mithilfe der HoloLens-Kamera und Speichern im App-Ordner.
Erfassen von Tippgesten vom Benutzer.

So erstellen Sie diese Klasse:

Wechseln Sie zum Ordner "Skripts", den Sie zuvor erstellt haben.
Klicken Sie mit der rechten Maustaste in den Ordner, C#-Skript erstellen>. Rufen Sie das Skript ImageCapture auf.
Doppelklicken Sie auf das neue ImageCapture-Skript , um es mit Visual Studio zu öffnen.

Fügen Sie am Anfang der -Datei die folgenden Namespaces hinzu:

    using System.IO;
    using System.Linq;
    using UnityEngine;
    using UnityEngine.XR.WSA.Input;
    using UnityEngine.XR.WSA.WebCam;

Fügen Sie dann die folgenden Variablen in der ImageCapture-Klasse oberhalb der Start() -Methode hinzu:

    public static ImageCapture instance; 
    public int tapsCount;
    private PhotoCapture photoCaptureObject = null;
    private GestureRecognizer recognizer;
    private bool currentlyCapturing = false;

Die variable tapsCount speichert die Anzahl der vom Benutzer erfassten Tippgesten. Diese Zahl wird bei der Benennung der aufgenommenen Bilder verwendet.

Code für Die Methoden Awake() und Start() muss jetzt hinzugefügt werden. Diese werden aufgerufen, wenn die Klasse initialisiert wird:

    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();
    }

Implementieren Sie einen Handler, der aufgerufen wird, wenn eine Tippbewegung auftritt.

    /// <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();
        }
    }

Mit der TapHandler()- Methode wird die Anzahl der vom Benutzer erfassten Tippen erhöht und die aktuelle Cursorposition verwendet, um zu bestimmen, wo eine neue Beschriftung positioniert werden soll.

Diese Methode ruft dann die ExecuteImageCaptureAndAnalysis() -Methode auf, um die Kernfunktionalität dieser Anwendung zu beginnen.

Nachdem ein Bild erfasst und gespeichert wurde, werden die folgenden Handler aufgerufen. Wenn der Prozess erfolgreich ist, wird das Ergebnis zur Analyse an den VisionManager (den Sie noch erstellen möchten) übergeben.

    /// <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()); 
    }

Fügen Sie dann die Methode hinzu, die von der Anwendung zum Starten des Bildaufnahmevorgangs verwendet wird, und speichern Sie das Bild.

    /// <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;
            });   
        });    
    }

Warnung

An diesem Punkt werden Sie feststellen, dass im Unity Editor Console Panel ein Fehler angezeigt wird. Dies liegt daran, dass der Code auf die VisionManager-Klasse verweist, die Sie im nächsten Kapitel erstellen.

Kapitel 7 – Aufruf von Azure und Image Analysis

Das letzte Skript, das Sie erstellen müssen, ist die VisionManager-Klasse .

Diese Klasse ist für Folgendes verantwortlich:

Laden des aktuellen Bilds, das als Bytearray erfasst wurde.
Senden des Bytearrays zur Analyse an Ihre Azure maschinelles Sehen API Service-Instanz.
Empfangen der Antwort als JSON-Zeichenfolge.
Deserialisieren der Antwort und Übergeben der resultierenden Tags an die ResultsLabel-Klasse .

So erstellen Sie diese Klasse:

Doppelklicken Sie auf den Ordner "Skripts ", um ihn zu öffnen.
Klicken Sie mit der rechten Maustaste in den Ordner "Skripts", und klicken Sie auf "C#-Skript erstellen>". Nennen Sie das Skript VisionManager.
Doppelklicken Sie auf das neue Skript, um es mit Visual Studio zu öffnen.

Aktualisieren Sie die Namespaces so, dass sie mit dem folgenden identisch sind, am Anfang der VisionManager-Klasse :

    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.IO;
    using UnityEngine;
    using UnityEngine.Networking;

Oben in Ihrem Skript müssen Sie in der VisionManager-Klasse (oberhalb der Start()-Methode zwei Klassen erstellen, die die deserialisierte JSON-Antwort aus Azure darstellen:
```
    [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;
    }
```
Hinweis

Die TagData - und AnalysedObject-Klassen müssen das [System.Serializable] -Attribut hinzugefügt haben, bevor die Deklaration mit den Unity-Bibliotheken deserialisiert werden kann.
In der VisionManager-Klasse sollten Sie die folgenden Variablen hinzufügen:
```
    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;
```
Warnung

Stellen Sie sicher, dass Sie Ihren Authentifizierungsschlüssel in die AuthorizationKey-Variable einfügen. Sie haben Ihren Authentifizierungsschlüssel am Anfang dieses Kurses, Kapitel 1, notiert.
Warnung

Die Variable "visionAnalysisEndpoint " kann sich von der in diesem Beispiel angegebenen unterscheiden. Der Westen bezieht sich streng auf Dienstinstanzen, die für die Region West-USA erstellt wurden. Aktualisieren Sie dies mit Ihrer Endpunkt-URL. Hier sind einige Beispiele dafür, wie das aussehen könnte:
- Europa, Westen: https://westeurope.api.cognitive.microsoft.com/vision/v1.0/analyze?visualFeatures=Tags
- Südostasien: https://southeastasia.api.cognitive.microsoft.com/vision/v1.0/analyze?visualFeatures=Tags
- Australien Ost: https://australiaeast.api.cognitive.microsoft.com/vision/v1.0/analyze?visualFeatures=Tags

Code für Awake muss jetzt hinzugefügt werden.

    private void Awake()
    {
        // allows this instance to behave like a singleton
        instance = this;
    }

Fügen Sie als Nächstes die Coroutine (mit der darunter liegenden statischen Streammethode) hinzu, die die Ergebnisse der Analyse des bilds abruft, das von der ImageCapture-Klasse erfasst wird.

    /// <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);
    }

Achten Sie darauf, ihre Änderungen in Visual Studio zu speichern, bevor Sie zu Unity zurückkehren.
Klicken Sie zurück im Unity-Editor, und ziehen Sie die Klassen VisionManager und ImageCapture aus dem Ordner "Skripts " in das Hauptkameraobjekt im Hierarchiebereich.

Kapitel 8 – Vor dem Gebäude

Um einen gründlichen Test Ihrer Anwendung durchzuführen, müssen Sie sie auf Ihre HoloLens querladen. Bevor Sie vorgehen, stellen Sie folgendes sicher:

Alle in Kapitel 2 erwähnten Einstellungen sind korrekt festgelegt.
Alle Skripts sind an das Main Camera-Objekt angefügt.
Alle Felder im Hauptkameraprüfungsbereich werden ordnungsgemäß zugewiesen.
Stellen Sie sicher, dass Sie Ihren Authentifizierungsschlüssel in die AuthorizationKey-Variable einfügen.
Stellen Sie sicher, dass Sie Ihren Endpunkt auch in Ihrem VisionManager-Skript überprüft haben und an Ihre Region ausgerichtet sind (in diesem Dokument wird standardmäßig west-us verwendet).

Kapitel 9 – Erstellen der UWP-Lösung und Querladen der Anwendung

Alles, was für den Unity-Abschnitt dieses Projekts erforderlich ist, wurde jetzt abgeschlossen, daher ist es an der Zeit, es aus Unity zu erstellen.

Navigieren Sie zu Buildeinstellungsdatei-Buildeinstellungen> - ...
Klicken Sie im Fenster "Buildeinstellungen " auf "Erstellen".
Wenn noch nicht geschehen, ticken Sie unter "Unity C#-Projekte".
Klicken Sie auf Erstellen. Unity startet ein Explorer-Fenster, in dem Sie einen Ordner erstellen und dann einen Ordner auswählen müssen, in dem die App erstellt werden soll. Erstellen Sie diesen Ordner jetzt, und nennen Sie ihn " App". Drücken Sie dann mit ausgewähltem App-Ordner "Ordner auswählen".
Unity beginnt mit dem Erstellen Ihres Projekts im App-Ordner .
Nachdem Unity das Erstellen abgeschlossen hat (es kann einige Zeit dauern), öffnet es ein Explorer Fenster an der Position Ihres Builds (überprüfen Sie Ihre Taskleiste, da sie möglicherweise nicht immer über Ihren Fenstern angezeigt wird, sondern Sie über dem Hinzufügen eines neuen Fensters informiert).

Kapitel 10 – Bereitstellen für HoloLens

So stellen Sie holoLens bereit:

Sie benötigen die IP-Adresse Ihrer HoloLens (für Remotebereitstellung) und um sicherzustellen, dass Sich Ihre HoloLens im Entwicklermodus befindet. Gehen Sie hierzu folgendermaßen vor:
1. Öffnen Sie beim Tragen Ihrer HoloLens die Einstellungen.
2. Wechseln sie zu den erweiterten Optionen für Netzwerk- und Internet-WLAN > >
3. Notieren Sie sich die IPv4-Adresse .
4. Navigieren Sie als Nächstes zurück zu "Einstellungen" und dann zu "Update & Sicherheit > für Entwickler".
5. Legen Sie den Entwicklermodus aktiviert fest.
Navigieren Sie zu Ihrem neuen Unity-Build (dem App-Ordner ), und öffnen Sie die Projektmappendatei mit Visual Studio.
Wählen Sie in der Lösungskonfiguration "Debuggen" aus.
Wählen Sie in der Lösungsplattform x86, Remotecomputer aus.
Wechseln Sie zum Menü " Erstellen", und klicken Sie auf "Lösung bereitstellen", um die Anwendung in Ihre HoloLens querzuladen.
Ihre App sollte jetzt in der Liste der installierten Apps auf Ihrer HoloLens angezeigt werden und kann gestartet werden!

Hinweis

Um das immersive Headset bereitzustellen, legen Sie die Lösungsplattform auf den lokalen Computer fest, und legen Sie die Konfiguration auf "Debuggen" fest, wobei x86 als Plattform verwendet wird. Stellen Sie dann mithilfe des Menüs "Erstellen" die Option "Lösung bereitstellen" auf dem lokalen Computer bereit.

Ihre fertige maschinelles Sehen-API-Anwendung

Herzlichen Glückwunsch, Sie haben eine Mixed Reality-App erstellt, die die Azure maschinelles Sehen-API nutzt, um reale Objekte zu erkennen und das Vertrauen dessen anzuzeigen, was gesehen wurde.

Lab-Ergebnis

Zusatzübungen

Übung 1

Genau wie Sie den Parameter "Tags" verwendet haben (wie im Endpunkt des VisionManager verwendeten Endpunkts), erweitern Sie die App, um andere Informationen zu erkennen. Schauen Sie sich an, welche anderen Parameter Sie auf HERE zugreifen können.

Übung 2

Zeigen Sie die zurückgegebenen Azure-Daten in einer unterhaltungellen und lesbaren Weise an, z. B. das Ausblenden der Zahlen. Als ob ein Bot möglicherweise mit dem Benutzer spricht.

Freigeben über

HoloLens (1. Generation) und Azure 302: Computer vision

Unterstützung für Geräte

Voraussetzungen

Vor der Installation

Kapitel 1 – Das Azure-Portal

Kapitel 2 – Einrichten des Unity-Projekts

Kapitel 3 – Einrichtung der Hauptkamera

Kapitel 4 – Einrichten des Bezeichnungssystems

Kapitel 5 – Erstellen der ResultsLabel-Klasse

Kapitel 6 – Erstellen der ImageCapture-Klasse

Kapitel 7 – Aufruf von Azure und Image Analysis

Kapitel 8 – Vor dem Gebäude

Kapitel 9 – Erstellen der UWP-Lösung und Querladen der Anwendung

Kapitel 10 – Bereitstellen für HoloLens

Ihre fertige maschinelles Sehen-API-Anwendung

Zusatzübungen

Übung 1

Übung 2

Zusätzliche Ressourcen