HoloLens (första generationen) och Azure 312: Robotintegrering

Artikel
07/04/2024

Kommentar

Självstudierna för Mixed Reality Academy har utformats med HoloLens (första generationen) och Mixed Reality Immersive Headsets i åtanke. Därför anser vi att det är viktigt att låta de här självstudierna vara kvar för utvecklare som fortfarande letar efter vägledning för att utveckla för dessa enheter. De här självstudierna uppdateras inte med de senaste verktygsuppsättningarna eller interaktionerna som används för HoloLens 2. De underhålls för att fortsätta arbeta med de enheter som stöds. Det kommer att finnas en ny serie självstudier som kommer att publiceras i framtiden som visar hur du utvecklar för HoloLens 2. Det här meddelandet uppdateras med en länk till de självstudierna när de publiceras.

I den här kursen får du lära dig hur du skapar och distribuerar en robot med hjälp av Microsoft Bot Framework V4 och kommunicerar med den via ett Windows Mixed Reality-program.

Skärmbild som visar kommunikation via ett Windows Mixed Reality-program.

Microsoft Bot Framework V4 är en uppsättning API:er som är utformade för att ge utvecklare verktyg för att skapa ett utökningsbart och skalbart robotprogram. Mer information finns på sidan Microsoft Bot Framework eller V4 Git-lagringsplatsen.

När du har slutfört den här kursen har du skapat ett Windows Mixed Reality-program som kan göra följande:

Använd en tryckgest för att starta roboten som lyssnar efter användarnas röst.
När användaren har sagt något försöker roboten ge ett svar.
Visa robotarna svara som text, placerad nära roboten, i Unity Scene.

I ditt program är det upp till dig hur du ska integrera resultaten med din design. Den här kursen är utformad för att lära dig hur du integrerar en Azure-tjänst med ditt Unity-projekt. Det är ditt jobb att använda den kunskap du får från den här kursen för att förbättra din mixed reality-app.

Stöd för enheter

Kurs	HoloLens	Uppslukande headset
MR och Azure 312: Robotintegrering	✔️	✔️

Kommentar

Den här kursen fokuserar främst på HoloLens, men du kan även tillämpa det du lär dig i den här kursen på Windows Mixed Reality-headset (VR). Eftersom integrerande (VR) headset inte har tillgängliga kameror behöver du en extern kamera ansluten till datorn. När du följer kursen visas anteckningar om eventuella ändringar som du kan behöva använda för att stödja uppslukande (VR) headset.

Förutsättningar

Kommentar

Den här självstudien är utformad för utvecklare som har grundläggande erfarenhet av Unity och C#. Tänk också på att kraven och de skriftliga instruktionerna i det här dokumentet representerar det som har testats och verifierats i skrivande stund (juli 2018). Du är fri att använda den senaste programvaran, som anges i artikeln installera verktyg , men det bör inte antas att informationen i den här kursen perfekt matchar vad du hittar i nyare programvara än vad som anges nedan.

Vi rekommenderar följande maskinvara och programvara för den här kursen:

En utvecklingsdator som är kompatibel med Windows Mixed Reality för avancerad (VR) headsetutveckling
Windows 10 Fall Creators Update (eller senare) med utvecklarläge aktiverat
Den senaste Windows 10 SDK
Unity 2017.4
Visual Studio 2017
Ett Windows Mixed Reality-headset (VR) eller Microsoft HoloLens med utvecklarläge aktiverat
Internetåtkomst för Azure och för hämtning av Azure Bot. Mer information finns på den här länken.

Innan du börjar

För att undvika problem med att skapa det här projektet rekommenderar vi starkt att du skapar projektet som nämns i den här självstudien i en rotmapp eller nära rotmapp (långa mappsökvägar kan orsaka problem vid byggtid).
Konfigurera och testa dina HoloLens. Om du behöver stöd för att konfigurera HoloLens ska du gå till installationsartikeln för HoloLens.
Det är en bra idé att utföra kalibrering och sensorjustering när du börjar utveckla en ny HoloLens-app (ibland kan det hjälpa till att utföra dessa uppgifter för varje användare).

Om du behöver hjälp med kalibrering kan du följa den här länken till artikeln HoloLens-kalibrering.

Om du vill ha hjälp med sensorjustering följer du den här länken till artikeln HoloLens Sensor Tuning.

Kapitel 1 – Skapa robotprogrammet

Det första steget är att skapa roboten som en lokal ASP.Net Core-webbapp. När du har slutfört och testat den publicerar du den på Azure-portalen.

Öppna Visual Studio. Skapa ett nytt projekt, välj ASP NET Core Web Application som projekttyp (du hittar det under underavsnittet .NET Core) och kalla det MyBot. Klicka på OK.
I fönstret som visas väljer du Tom. Kontrollera också att målet är inställt på ASP NET Core 2.0 och att autentiseringen är inställd på Ingen autentisering. Klicka på OK.
Lösningen öppnas nu. Högerklicka på Solution Mybot i Istraživač rešenja och klicka på Hantera NuGet-paket för lösning.
På fliken Bläddra söker du efter Microsoft.Bot.Builder.Integration.AspNet.Core (se till att inkludera förhandsversionen är markerad). Välj paketversion 4.0.1-preview och markera projektrutorna. Klicka sedan på Installera. Nu har du installerat de bibliotek som behövs för Bot Framework v4. Stäng NuGet-sidan.
Högerklicka på projektet MyBot i Istraživač rešenja och klicka på Lägg till | klass.
Ge klassen namnet MyBot och klicka på Lägg till.
Upprepa föregående punkt för att skapa en annan klass med namnet ConversationContext.
Högerklicka på wwwroot i Istraživač rešenja och klicka på Lägg till | nytt objekt. Välj HTML-sida (du hittar den under underavsnittswebb). Ge filen namnet default.html. Klicka på Lägg till.
Listan över klasser/objekt i Istraživač rešenja bör se ut som bilden nedan.
Dubbelklicka på klassen ConversationContext . Den här klassen ansvarar för att hålla de variabler som används av roboten för att upprätthålla konversationens kontext. Dessa konversationskontextvärden underhålls i en instans av den här klassen, eftersom alla instanser av Klassen MyBot uppdateras varje gång en aktivitet tas emot. Lägg till följande kod i klassen:
```
namespace MyBot
{
    public static class ConversationContext
    {
        internal static string userName;

        internal static string userMsg;
    }
}
```

Dubbelklicka på klassen MyBot . Den här klassen är värd för de hanterare som anropas av inkommande aktivitet från kunden. I den här klassen lägger du till koden som används för att skapa konversationen mellan roboten och kunden. Som tidigare nämnts initieras en instans av den här klassen varje gång en aktivitet tas emot. Lägg till följande kod i den här klassen:

using Microsoft.Bot;
using Microsoft.Bot.Builder;
using Microsoft.Bot.Schema;
using System.Threading.Tasks;

namespace MyBot
{
    public class MyBot : IBot
    {       
        public async Task OnTurn(ITurnContext context)
        {
            ConversationContext.userMsg = context.Activity.Text;

            if (context.Activity.Type is ActivityTypes.Message)
            {
                if (string.IsNullOrEmpty(ConversationContext.userName))
                {
                    ConversationContext.userName = ConversationContext.userMsg;
                    await context.SendActivity($"Hello {ConversationContext.userName}. Looks like today it is going to rain. \nLuckily I have umbrellas and waterproof jackets to sell!");
                }
                else
                {
                    if (ConversationContext.userMsg.Contains("how much"))
                    {
                        if (ConversationContext.userMsg.Contains("umbrella")) await context.SendActivity($"Umbrellas are $13.");
                        else if (ConversationContext.userMsg.Contains("jacket")) await context.SendActivity($"Waterproof jackets are $30.");
                        else await context.SendActivity($"Umbrellas are $13. \nWaterproof jackets are $30.");
                    }
                    else if (ConversationContext.userMsg.Contains("color") || ConversationContext.userMsg.Contains("colour"))
                    {
                        await context.SendActivity($"Umbrellas are black. \nWaterproof jackets are yellow.");
                    }
                    else
                    {
                        await context.SendActivity($"Sorry {ConversationContext.userName}. I did not understand the question");
                    }
                }
            }
            else
            {

                ConversationContext.userMsg = string.Empty;
                ConversationContext.userName = string.Empty;
                await context.SendActivity($"Welcome! \nI am the Weather Shop Bot \nWhat is your name?");
            }

        }
    }
}

Dubbelklicka på startklassen. Den här klassen initierar roboten. Lägg till följande kod i klassen:

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Bot.Builder.BotFramework;
using Microsoft.Bot.Builder.Integration.AspNet.Core;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;

namespace MyBot
{
public class Startup
    {
        public IConfiguration Configuration { get; }

        public Startup(IHostingEnvironment env)
        {
            var builder = new ConfigurationBuilder()
                .SetBasePath(env.ContentRootPath)
                .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
                .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
                .AddEnvironmentVariables();
            Configuration = builder.Build();
        }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddSingleton(_ => Configuration);
            services.AddBot<MyBot>(options =>
            {
                options.CredentialProvider = new ConfigurationCredentialProvider(Configuration);
            });
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseDefaultFiles();
            app.UseStaticFiles();
            app.UseBotFramework();
        }
    }
}

Öppna programklassfilen och kontrollera att koden i den är samma som följande:

using Microsoft.AspNetCore;
using Microsoft.AspNetCore.Hosting;

namespace MyBot
{
    public class Program
    {
        public static void Main(string[] args)
        {
            BuildWebHost(args).Run();
        }

        public static IWebHost BuildWebHost(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
                .UseStartup<Startup>()
                .Build();
    }
}

Kom ihåg att spara ändringarna genom att gå till Spara>alla filer i verktygsfältet överst i Visual Studio.

Kapitel 2 – Skapa Azure Bot Service

Nu när du har skapat koden för din robot måste du publicera den till en instans av Web App Bot Service på Azure-portalen. Det här kapitlet visar hur du skapar och konfigurerar bottjänsten i Azure och sedan publicerar din kod till den.

Logga först in på Azure Portal (https://portal.azure.com).
1. Om du inte redan har ett Azure-konto måste du skapa ett. Om du följer den här självstudien i en klassrums- eller labbsituation ber du din instruktör eller någon av rektorerna om hjälp med att konfigurera ditt nya konto.
När du är inloggad klickar du på Skapa en resurs i det övre vänstra hörnet och söker efter webbapprobot och klickar på Retur.
Den nya sidan innehåller en beskrivning av Web App Bot Service. Längst ned till vänster på den här sidan väljer du knappen Skapa för att skapa en association med den här tjänsten.
När du har klickat på Skapa:
1. Infoga önskat namn för den här tjänstinstansen.
2. Välj en prenumeration.
3. Välj en resursgrupp eller skapa en ny. En resursgrupp är ett sätt att övervaka, kontrollera åtkomst, etablera och hantera fakturering för en samling Azure-tillgångar. Vi rekommenderar att du behåller alla Azure-tjänster som är associerade med ett enskilt projekt (t.ex. dessa kurser) under en gemensam resursgrupp.
  
  Om du vill läsa mer om Azure-resursgrupper följer du den här länken
4. Fastställa platsen för resursgruppen (om du skapar en ny resursgrupp). Platsen skulle helst vara i den region där programmet skulle köras. Vissa Azure-tillgångar är bara tillgängliga i vissa regioner.
5. Välj den prisnivå som är lämplig för dig, om det är första gången du skapar en webbappsrobottjänst bör en kostnadsfri nivå (med namnet F0) vara tillgänglig för dig
6. Appnamnet kan bara lämnas samma som robotnamnet.
7. Lämna robotmallen som Basic (C#).
8. App Service-plan/Plats ska ha fyllts i automatiskt för ditt konto.
9. Ange den Azure Storage som du vill använda som värd för din robot. Om du inte redan har en kan du skapa den här.
10. Du måste också bekräfta att du har förstått de villkor som gäller för den här tjänsten.
11. Klicka på Skapa.
När du har klickat på Skapa måste du vänta tills tjänsten har skapats. Det kan ta en minut.
Ett meddelande visas i portalen när tjänstinstansen har skapats.
Klicka på meddelandet för att utforska din nya tjänstinstans.
Klicka på knappen Gå till resurs i meddelandet för att utforska din nya tjänstinstans. Du kommer att tas till din nya Azure Service-instans.
Nu måste du konfigurera en funktion med namnet Direct Line för att klientprogrammet ska kunna kommunicera med den här robottjänsten. Klicka på Kanaler och klicka sedan på Konfigurera direktlinjekanal i avsnittet Lägg till en aktuell kanal.
På den här sidan hittar du de hemliga nycklar som gör att klientappen kan autentisera med roboten. Klicka på knappen Visa och ta en kopia av en av de nycklar som visas, eftersom du behöver detta senare i projektet.

Kapitel 3 – Publicera roboten till Azure Web App Bot Service

Nu när tjänsten är klar måste du publicera din robotkod, som du skapade tidigare, till din nyligen skapade Web App Bot Service.

Kommentar

Du måste publicera din robot till Azure Service varje gång du gör ändringar i robotlösningen/koden.

Gå tillbaka till din Visual Studio-lösning som du skapade tidigare.
Högerklicka på ditt MyBot-projekt i Istraživač rešenja och klicka sedan på Publicera.
På sidan Välj ett publiceringsmål klickar du på App Service och sedan på Välj befintlig. Klicka slutligen på Skapa profil (du kan behöva klicka på listrutepilen tillsammans med knappen Publicera, om detta inte visas).
Om du ännu inte är inloggad på ditt Microsoft-konto måste du göra det här.
På sidan Publicera ser du att du måste ange samma prenumeration som du använde för att skapa Web App Bot Service. Ange sedan Visa som resursgrupp och i listrutans mappstruktur väljer du den resursgrupp som du skapade tidigare. Klicka på OK.
Klicka nu på knappen Publicera och vänta tills roboten har publicerats (det kan ta några minuter).

Kapitel 4 – Konfigurera Unity-projektet

Följande är en typisk konfiguration för utveckling med mixad verklighet och är därför en bra mall för andra projekt.

Öppna Unity och klicka på Nytt.
Nu måste du ange ett Unity-projektnamn. Infoga HoloLens-robot. Kontrollera att projektmallen är inställd på 3D. Ange platsen till någonstans som passar dig (kom ihåg att närmare rotkataloger är bättre). Klicka sedan på Skapa projekt.
När Unity är öppet är det värt att kontrollera att standardskriptredigeraren är inställd på Visual Studio. Gå till Redigera > inställningar och gå sedan till Externa verktyg från det nya fönstret. Ändra extern skriptredigerare till Visual Studio 2017. Stäng fönstret Inställningar .
Gå sedan till Inställningar för filbygge > och välj Universell Windows-plattform och klicka sedan på knappen Växla plattform för att tillämpa ditt val.
När du fortfarande är i Filversionsinställningar > och se till att:
1. Målenheten är inställd på HoloLens
  
  För de uppslukande headseten anger du Målenhet till Valfri enhet.
2. Byggtyp är inställd på D3D
3. SDK är inställt på Senaste installerat
4. Visual Studio-versionen är inställd på Senaste installerad
5. Build and Run är inställt på Lokal dator
6. Spara scenen och lägg till den i bygget.
  1. Gör detta genom att välja Lägg till öppna scener. Ett spara-fönster visas.
  2. Skapa en ny mapp för detta, och eventuella framtida scenarier, välj sedan knappen Ny mapp , för att skapa en ny mapp, ge den namnet Scener.
  3. Öppna den nyligen skapade mappen Scener och skriv BotScene i fältet Filnamn: text och klicka sedan på Spara.
7. De återstående inställningarna i Bygginställningar bör vara kvar som standard för tillfället.
I fönstret Bygginställningar klickar du på knappen Spelarinställningar. Då öppnas den relaterade panelen i det utrymme där inspektören finns.
I den här panelen måste några inställningar verifieras:
1. På fliken Andra inställningar :
  1. Skriptkörningsversionen bör vara experimentell (NET 4.6-motsvarighet). Om du ändrar detta krävs en omstart av redigeraren.
  2. Skriptserverdelen ska vara .NET
  3. API-kompatibilitetsnivån ska vara .NET 4.6
2. På fliken Publiceringsinställningar går du till Funktioner och kontrollerar:
  - InternetClient
  - Mikrofon
3. Längre ned på panelen, i XR-inställningar (som finns under Publiceringsinställningar), markerar du Virtual Reality Supported (Virtual Reality Supported) och kontrollerar att Windows Mixed Reality SDK har lagts till.
Tillbaka i Bygginställningar Unity C# -projekt är inte längre nedtonade. Markera kryssrutan bredvid detta.
Stäng fönstret Build Settings (Bygginställningar).
Spara din scen och ditt projekt (FILE > SAVE SCENE/FILE > SAVE PROJECT).

Kapitel 5 – Kamerainstallation

Viktigt!

Om du vill hoppa över unity-konfigurationskomponenten i den här kursen och fortsätta direkt till kod kan du ladda ned den här Azure-MR-312-Package.unitypackage, importera den till ditt projekt som ett anpassat paket och sedan fortsätta från kapitel 7.

I panelen Hierarki väljer du huvudkameran.
När du har valt kan du se alla komponenter i huvudkameran i panelen Kontroll.
1. Kameraobjektet måste ha namnet Main Camera (notera stavningen)
2. Huvudkamerataggen måste vara inställd på MainCamera (notera stavningen)
3. Kontrollera att transformeringspositionen är inställd på 0, 0, 0
4. Ange Rensa flaggor till Enfärgad.
5. Ange bakgrundsfärgen för kamerakomponenten till Black, Alpha 0 (Hex Code: #000000000)

Kapitel 6 – Importera Newtonsoft-biblioteket

För att hjälpa dig att deserialisera och serialisera objekt som tagits emot och skickats till bottjänsten måste du ladda ned Newtonsoft-biblioteket . Du hittar en kompatibel version som redan är organiserad med rätt Unity-mappstruktur här.

Om du vill importera Newtonsoft-biblioteket till projektet använder du Unity-paketet som medföljer den här kursen.

Lägg till .unitypackage i Unity med menyalternativet Importera paket>för tillgångar.>
I rutan Importera Unity-paket som visas kontrollerar du att allt under (och inklusive) plugin-program har valts .
Klicka på knappen Importera för att lägga till objekten i projektet.
Gå till mappen Newtonsoft under Plugin-program i projektvyn och välj Newtonsoft-plugin-programmet.
När Newtonsoft-plugin-programmet har valts kontrollerar du att Alla plattformar är avmarkerade och kontrollerar sedan att WSAPlayer också är avmarkerat och klickar sedan på Använd. Detta är bara för att bekräfta att filerna är korrekt konfigurerade.

Kommentar

Om du markerar dessa plugin-program konfigureras de så att de endast används i Unity-redigeraren. Det finns en annan uppsättning av dem i WSA-mappen som ska användas när projektet har exporterats från Unity.
Därefter måste du öppna WSA-mappen i mappen Newtonsoft . Du ser en kopia av samma fil som du just konfigurerade. Välj filen och se sedan till att du i inspektören
- Alla plattformar är avmarkerade
- endast WSAPlayer är markerat
- Dont-processen är markerad

Kapitel 7 – Skapa BotTag

Skapa ett nytt taggobjekt med namnet BotTag. Välj huvudkameran i scenen. Klicka på den nedrullningsbara menyn Tagg i panelen Kontroll. Klicka på Lägg till tagg.
Klicka på symbolen + . Ge den nya taggen namnet BotTag, Spara.

Varning

Använd inte BotTag på huvudkameran. Om du har gjort detta av misstag måste du ändra huvudkamera-taggen tillbaka till MainCamera.

Kapitel 8 – Skapa klassen BotObjects

Det första skriptet du behöver skapa är klassen BotObjects, som är en tom klass som skapats så att en serie andra klassobjekt kan lagras i samma skript och användas av andra skript i scenen.

Skapandet av den här klassen är bara ett arkitektoniskt val. Dessa objekt kan i stället finnas i robotskriptet som du skapar senare i den här kursen.

Så här skapar du den här klassen:

Högerklicka i projektpanelen och sedan på Skapa > mapp. Ge mappen namnet Skript.
Dubbelklicka på mappen Skript för att öppna den. Högerklicka sedan i mappen och välj Skapa > C#-skript. Ge skriptet namnet BotObjects.
Dubbelklicka på det nya BotObjects-skriptet för att öppna det med Visual Studio.

Ta bort innehållet i skriptet och ersätt det med följande kod:

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class BotObjects : MonoBehaviour{}

/// <summary>
/// Object received when first opening a conversation
/// </summary>
[Serializable]
public class ConversationObject
{
    public string ConversationId;
    public string token;
    public string expires_in;
    public string streamUrl;
    public string referenceGrammarId;
}

/// <summary>
/// Object including all Activities
/// </summary>
[Serializable]
public class ActivitiesRootObject
{
    public List<Activity> activities { get; set; }
    public string watermark { get; set; }
}
[Serializable]
public class Conversation
{
    public string id { get; set; }
}
[Serializable]
public class From
{
    public string id { get; set; }
    public string name { get; set; }
}
[Serializable]
public class Activity
{
    public string type { get; set; }
    public string channelId { get; set; }
    public Conversation conversation { get; set; }
    public string id { get; set; }
    public From from { get; set; }
    public string text { get; set; }
    public string textFormat { get; set; }
    public DateTime timestamp { get; set; }
    public string serviceUrl { get; set; }
}

Se till att spara ändringarna i Visual Studio innan du återvänder till Unity.

Kapitel 9 – Skapa klassen GazeInput

Nästa klass som du ska skapa är klassen GazeInput . Den här klassen ansvarar för:

Skapa en markör som representerar spelarens blick .
Identifiera objekt som träffats av spelarens blick och hålla en referens till identifierade objekt.

Så här skapar du den här klassen:

Gå till mappen Skript som du skapade tidigare.
Högerklicka i mappen Skapa > C#-skript. Anropa skriptet GazeInput.
Dubbelklicka på det nya GazeInput-skriptet för att öppna det med Visual Studio.

Infoga följande rad ovanpå klassnamnet:

/// <summary>
/// Class responsible for the User's gaze interactions
/// </summary>
[System.Serializable]
public class GazeInput : MonoBehaviour

Lägg sedan till följande variabler i klassen GazeInput ovanför metoden Start( ):

    [Tooltip("Used to compare whether an object is to be interacted with.")]
    internal string InteractibleTag = "BotTag";

    /// <summary>
    /// Length of the gaze
    /// </summary>
    internal float GazeMaxDistance = 300;

    /// <summary>
    /// Object currently gazed
    /// </summary>
    internal GameObject FocusedObject { get; private set; }

    internal GameObject _oldFocusedObject { get; private set; }

    internal RaycastHit HitInfo { get; private set; }

    /// <summary>
    /// Cursor object visible in the scene
    /// </summary>
    internal GameObject Cursor { get; private set; }

    internal bool Hit { get; private set; }

    internal Vector3 Position { get; private set; }

    internal Vector3 Normal { get; private set; }

    private Vector3 _gazeOrigin;

    private Vector3 _gazeDirection;

Kod för Start() -metoden ska läggas till. Detta anropas när klassen initierar:

    /// <summary>
    /// Start method used upon initialization.
    /// </summary>
    internal virtual void Start()
    {
        FocusedObject = null;
        Cursor = CreateCursor();
    }

Implementera en metod som instansierar och konfigurerar blickmarkören:

    /// <summary>
    /// Method to create a cursor object.
    /// </summary>
    internal GameObject CreateCursor()
    {
        GameObject newCursor = GameObject.CreatePrimitive(PrimitiveType.Sphere);
        newCursor.SetActive(false);
        // Remove the collider, so it does not block Raycast.
        Destroy(newCursor.GetComponent<SphereCollider>());
        newCursor.transform.localScale = new Vector3(0.05f, 0.05f, 0.05f);
        Material mat = new Material(Shader.Find("Diffuse"));
        newCursor.GetComponent<MeshRenderer>().material = mat;
        mat.color = Color.HSVToRGB(0.0223f, 0.7922f, 1.000f);
        newCursor.SetActive(true);

        return newCursor;
    }

Implementera de metoder som konfigurerar Raycast från huvudkameran och håller reda på det aktuella fokuserade objektet.

    /// <summary>
    /// Called every frame
    /// </summary>
    internal virtual void Update()
    {
        _gazeOrigin = Camera.main.transform.position;

        _gazeDirection = Camera.main.transform.forward;

        UpdateRaycast();
    }


    /// <summary>
    /// Reset the old focused object, stop the gaze timer, and send data if it
    /// is greater than one.
    /// </summary>
    private void ResetFocusedObject()
    {
        // Ensure the old focused object is not null.
        if (_oldFocusedObject != null)
        {
            if (_oldFocusedObject.CompareTag(InteractibleTag))
            {
                // Provide the OnGazeExited event.
                _oldFocusedObject.SendMessage("OnGazeExited", 
                    SendMessageOptions.DontRequireReceiver);
            }
        }
    }


    private void UpdateRaycast()
    {
        // Set the old focused gameobject.
        _oldFocusedObject = FocusedObject;
        RaycastHit hitInfo;

        // Initialize Raycasting.
        Hit = Physics.Raycast(_gazeOrigin,
            _gazeDirection,
            out hitInfo,
            GazeMaxDistance);
        HitInfo = hitInfo;

        // Check whether raycast has hit.
        if (Hit == true)
        {
            Position = hitInfo.point;
            Normal = hitInfo.normal;

            // Check whether the hit has a collider.
            if (hitInfo.collider != null)
            {
                // Set the focused object with what the user just looked at.
                FocusedObject = hitInfo.collider.gameObject;
            }
            else
            {
                // Object looked on is not valid, set focused gameobject to null.
                FocusedObject = null;
            }
        }
        else
        {
            // No object looked upon, set focused gameobject to null.
            FocusedObject = null;

            // Provide default position for cursor.
            Position = _gazeOrigin + (_gazeDirection * GazeMaxDistance);

            // Provide a default normal.
            Normal = _gazeDirection;
        }

        // Lerp the cursor to the given position, which helps to stabilize the gaze.
        Cursor.transform.position = Vector3.Lerp(Cursor.transform.position, Position, 0.6f);

        // Check whether the previous focused object is this same. If so, reset the focused object.
        if (FocusedObject != _oldFocusedObject)
        {
            ResetFocusedObject();
            if (FocusedObject != null)
            {
                if (FocusedObject.CompareTag(InteractibleTag))
                {
                    // Provide the OnGazeEntered event.
                    FocusedObject.SendMessage("OnGazeEntered",
                        SendMessageOptions.DontRequireReceiver);
                }
            }
        }
    }

Se till att spara ändringarna i Visual Studio innan du återvänder till Unity.

Kapitel 10 – Skapa robotklassen

Skriptet som du ska skapa nu kallas robot. Det här är kärnklassen för ditt program och lagrar:

Dina autentiseringsuppgifter för webbapprobot
Metoden som samlar in användarens röstkommandon
Den metod som krävs för att initiera konversationer med din webbappsrobot
Den metod som krävs för att skicka meddelanden till din webbappsrobot

För att skicka meddelanden till Bot Service skapar Coroutine SendMessageToBot() en aktivitet, som är ett objekt som identifieras av Bot Framework som data som skickas av användaren.

Så här skapar du den här klassen:

Dubbelklicka på mappen Skript för att öppna den.
Högerklicka i mappen Skript och klicka på Skapa > C#-skript. Namnge skriptroboten.
Dubbelklicka på det nya skriptet för att öppna det med Visual Studio.

Uppdatera namnrymderna så att de är samma som följande överst i robotklassen:

using Newtonsoft.Json;
using System.Collections;
using System.Text;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.Windows.Speech;

I robotklassen lägger du till följande variabler:

    /// <summary>
    /// Static instance of this class
    /// </summary>
    public static Bot Instance;

    /// <summary>
    /// Material of the sphere representing the Bot in the scene
    /// </summary>
    internal Material botMaterial;

    /// <summary>
    /// Speech recognizer class reference, which will convert speech to text.
    /// </summary>
    private DictationRecognizer dictationRecognizer;

    /// <summary>
    /// Use this variable to identify the Bot Id
    /// Can be any value
    /// </summary>
    private string botId = "MRBotId";

    /// <summary>
    /// Use this variable to identify the Bot Name
    /// Can be any value
    /// </summary>
    private string botName = "MRBotName";

    /// <summary>
    /// The Bot Secret key found on the Web App Bot Service on the Azure Portal
    /// </summary>
    private string botSecret = "-- Add your Secret Key here --"; 

    /// <summary>
    /// Bot Endpoint, v4 Framework uses v3 endpoint at this point in time
    /// </summary>
    private string botEndpoint = "https://directline.botframework.com/v3/directline";

    /// <summary>
    /// The conversation object reference
    /// </summary>
    private ConversationObject conversation;

    /// <summary>
    /// Bot states to regulate the application flow
    /// </summary>
    internal enum BotState {ReadyToListen, Listening, Processing}

    /// <summary>
    /// Flag for the Bot state
    /// </summary>
    internal BotState botState;

    /// <summary>
    /// Flag for the conversation status
    /// </summary>
    internal bool conversationStarted = false;

Kommentar

Se till att du infogar robothemlighetsnyckeln i botSecret-variabeln. Du kommer att ha noterat din bothemlighetsnyckel i början av den här kursen, i kapitel 2, steg 10.

Kod för Awake() och Start() måste nu läggas till.

    /// <summary>
    /// Called on Initialization
    /// </summary>
    void Awake()
    {
        Instance = this;
    }

    /// <summary>
    /// Called immediately after Awake method
    /// </summary>
    void Start()
    {
        botState = BotState.ReadyToListen;
    }

Lägg till de två hanterare som anropas av talbiblioteken när röstinsamlingen börjar och slutar. DictationRecognizer slutar automatiskt att samla in användarens röst när användaren slutar tala.

    /// <summary>
    /// Start microphone capture.
    /// </summary>
    public void StartCapturingAudio()
    {
        botState = BotState.Listening;
        botMaterial.color = Color.red;

        // Start dictation
        dictationRecognizer = new DictationRecognizer();
        dictationRecognizer.DictationResult += DictationRecognizer_DictationResult;
        dictationRecognizer.Start();
    }


    /// <summary>
    /// Stop microphone capture.
    /// </summary>
    public void StopCapturingAudio()
    {
        botState = BotState.Processing;
        dictationRecognizer.Stop();
    }

Följande hanterare samlar in resultatet av användarens röstindata och anropar den coroutine som ansvarar för att skicka meddelandet till Web App Bot Service.

    /// <summary>
    /// This handler is called every time the Dictation detects a pause in the speech. 
    /// </summary>
    private void DictationRecognizer_DictationResult(string text, ConfidenceLevel confidence)
    {
        // Update UI with dictation captured
        Debug.Log($"User just said: {text}");      

        // Send dictation to Bot
        StartCoroutine(SendMessageToBot(text, botId, botName, "message"));
        StopCapturingAudio();
    }

Följande coroutine anropas för att starta en konversation med roboten. Du kommer att märka att när konversationsanropet är klart anropas SendMessageToCoroutine() genom att skicka en serie parametrar som anger att aktiviteten ska skickas till bottjänsten som ett tomt meddelande. Detta görs för att uppmana bottjänsten att initiera dialogen.

    /// <summary>
    /// Request a conversation with the Bot Service
    /// </summary>
    internal IEnumerator StartConversation()
    {
        string conversationEndpoint = string.Format("{0}/conversations", botEndpoint);

        WWWForm webForm = new WWWForm();

        using (UnityWebRequest unityWebRequest = UnityWebRequest.Post(conversationEndpoint, webForm))
        {
            unityWebRequest.SetRequestHeader("Authorization", "Bearer " + botSecret);
            unityWebRequest.downloadHandler = new DownloadHandlerBuffer();

            yield return unityWebRequest.SendWebRequest();
            string jsonResponse = unityWebRequest.downloadHandler.text;

            conversation = new ConversationObject();
            conversation = JsonConvert.DeserializeObject<ConversationObject>(jsonResponse);
            Debug.Log($"Start Conversation - Id: {conversation.ConversationId}");
            conversationStarted = true; 
        }

        // The following call is necessary to create and inject an activity of type //"conversationUpdate" to request a first "introduction" from the Bot Service.
        StartCoroutine(SendMessageToBot("", botId, botName, "conversationUpdate"));
    }

Följande coroutine anropas för att skapa aktiviteten som ska skickas till Bot Service.

    /// <summary>
    /// Send the user message to the Bot Service in form of activity
    /// and call for a response
    /// </summary>
    private IEnumerator SendMessageToBot(string message, string fromId, string fromName, string activityType)
    {
        Debug.Log($"SendMessageCoroutine: {conversation.ConversationId}, message: {message} from Id: {fromId} from name: {fromName}");

        // Create a new activity here
        Activity activity = new Activity();
        activity.from = new From();
        activity.conversation = new Conversation();
        activity.from.id = fromId;
        activity.from.name = fromName;
        activity.text = message;
        activity.type = activityType;
        activity.channelId = "DirectLineChannelId";
        activity.conversation.id = conversation.ConversationId;     

        // Serialize the activity
        string json = JsonConvert.SerializeObject(activity);

        string sendActivityEndpoint = string.Format("{0}/conversations/{1}/activities", botEndpoint, conversation.ConversationId);

        // Send the activity to the Bot
        using (UnityWebRequest www = new UnityWebRequest(sendActivityEndpoint, "POST"))
        {
            www.uploadHandler = new UploadHandlerRaw(Encoding.UTF8.GetBytes(json));

            www.downloadHandler = new DownloadHandlerBuffer();
            www.SetRequestHeader("Authorization", "Bearer " + botSecret);
            www.SetRequestHeader("Content-Type", "application/json");

            yield return www.SendWebRequest();

            // extrapolate the response Id used to keep track of the conversation
            string jsonResponse = www.downloadHandler.text;
            string cleanedJsonResponse = jsonResponse.Replace("\r\n", string.Empty);
            string responseConvId = cleanedJsonResponse.Substring(10, 30);

            // Request a response from the Bot Service
            StartCoroutine(GetResponseFromBot(activity));
        }
    }

Följande coroutine anropas för att begära ett svar efter att en aktivitet har skickats till Bot Service.

    /// <summary>
    /// Request a response from the Bot by using a previously sent activity
    /// </summary>
    private IEnumerator GetResponseFromBot(Activity activity)
    {
        string getActivityEndpoint = string.Format("{0}/conversations/{1}/activities", botEndpoint, conversation.ConversationId);

        using (UnityWebRequest unityWebRequest1 = UnityWebRequest.Get(getActivityEndpoint))
        {
            unityWebRequest1.downloadHandler = new DownloadHandlerBuffer();
            unityWebRequest1.SetRequestHeader("Authorization", "Bearer " + botSecret);

            yield return unityWebRequest1.SendWebRequest();

            string jsonResponse = unityWebRequest1.downloadHandler.text;

            ActivitiesRootObject root = new ActivitiesRootObject();
            root = JsonConvert.DeserializeObject<ActivitiesRootObject>(jsonResponse);

            foreach (var act in root.activities)
            {
                Debug.Log($"Bot Response: {act.text}");
                SetBotResponseText(act.text);
            }

            botState = BotState.ReadyToListen;
            botMaterial.color = Color.blue;
        }
    }

Den sista metoden som ska läggas till i den här klassen krävs för att visa meddelandet i scenen:
```
    /// <summary>
    /// Set the UI Response Text of the bot
    /// </summary>
    internal void SetBotResponseText(string responseString)
    {        
        SceneOrganiser.Instance.botResponseText.text =  responseString;
    }
```
Kommentar

Du kan se ett fel i Unity-redigerarkonsolen om att klassen SceneOrganiser saknas. Ignorera det här meddelandet eftersom du skapar den här klassen senare i självstudien.
Se till att spara ändringarna i Visual Studio innan du återvänder till Unity.

Kapitel 11 – Skapa klassen Interaktioner

Klassen som du ska skapa nu kallas Interaktioner. Den här klassen används för att identifiera HoloLens Tap Input från användaren.

Om användaren trycker på robotobjektet i scenen och roboten är redo att lyssna efter röstindata ändrar robotobjektet färg till röd och börjar lyssna efter röstindata.

Den här klassen ärver från klassen GazeInput och kan därför referera till metoden Start() och variabler från den klassen, som anges med hjälp av bas.

Så här skapar du den här klassen:

Dubbelklicka på mappen Skript för att öppna den.
Högerklicka i mappen Skript och klicka på Skapa > C#-skript. Ge skriptet namnet Interaktioner.
Dubbelklicka på det nya skriptet för att öppna det med Visual Studio.
Uppdatera namnrymderna och klassarvet så att de är samma som följande överst i klassen Interaktioner:
```
using UnityEngine.XR.WSA.Input;

public class Interactions : GazeInput
{
```

I klassen Interaktioner lägger du till följande variabel:

    /// <summary>
    /// Allows input recognition with the HoloLens
    /// </summary>
    private GestureRecognizer _gestureRecognizer;

Lägg sedan till metoden Start( ):

    /// <summary>
    /// Called on initialization, after Awake
    /// </summary>
    internal override void Start()
    {
        base.Start();

        //Register the application to recognize HoloLens user inputs
        _gestureRecognizer = new GestureRecognizer();
        _gestureRecognizer.SetRecognizableGestures(GestureSettings.Tap);
        _gestureRecognizer.Tapped += GestureRecognizer_Tapped;
        _gestureRecognizer.StartCapturingGestures();
    }

Lägg till den hanterare som utlöses när användaren utför tryckgesten framför HoloLens-kameran

    /// <summary>
    /// Detects the User Tap Input
    /// </summary>
    private void GestureRecognizer_Tapped(TappedEventArgs obj)
    {
        // Ensure the bot is being gazed upon.
        if(base.FocusedObject != null)
        {
            // If the user is tapping on Bot and the Bot is ready to listen
            if (base.FocusedObject.name == "Bot" && Bot.Instance.botState == Bot.BotState.ReadyToListen)
            {
                // If a conversation has not started yet, request one
                if(Bot.Instance.conversationStarted)
                {
                    Bot.Instance.SetBotResponseText("Listening...");
                    Bot.Instance.StartCapturingAudio();
                }
                else
                {
                    Bot.Instance.SetBotResponseText("Requesting Conversation...");
                    StartCoroutine(Bot.Instance.StartConversation());
                }                                  
            }
        }
    }

Se till att spara ändringarna i Visual Studio innan du återvänder till Unity.

Kapitel 12 – Skapa klassen SceneOrganiser

Den sista klassen som krävs i det här labbet kallas SceneOrganiser. Den här klassen konfigurerar scenen programmatiskt genom att lägga till komponenter och skript i huvudkameran och skapa lämpliga objekt i scenen.

Så här skapar du den här klassen:

Dubbelklicka på mappen Skript för att öppna den.
Högerklicka i mappen Skript och klicka på Skapa > C#-skript. Ge skriptet namnet SceneOrganiser.
Dubbelklicka på det nya skriptet för att öppna det med Visual Studio.

I klassen SceneOrganiser lägger du till följande variabler:

    /// <summary>
    /// Static instance of this class
    /// </summary>
    public static SceneOrganiser Instance;

    /// <summary>
    /// The 3D text representing the Bot response
    /// </summary>
    internal TextMesh botResponseText;

Lägg sedan till metoderna Awake() och Start():

    /// <summary>
    /// Called on Initialization
    /// </summary>
    private void Awake()
    {
        Instance = this;
    }

    /// <summary>
    /// Called immediately after Awake method
    /// </summary>
    void Start ()
    {
        // Add the GazeInput class to this object
        gameObject.AddComponent<GazeInput>();

        // Add the Interactions class to this object
        gameObject.AddComponent<Interactions>();

        // Create the Bot in the scene
        CreateBotInScene();
    }

Lägg till följande metod som ansvarar för att skapa robotobjektet i scenen och konfigurera parametrarna och komponenterna:

    /// <summary>
    /// Create the Sign In button object in the scene
    /// and sets its properties
    /// </summary>
    private void CreateBotInScene()
    {
        GameObject botObjInScene = GameObject.CreatePrimitive(PrimitiveType.Sphere);
        botObjInScene.name = "Bot";

        // Add the Bot class to the Bot GameObject
        botObjInScene.AddComponent<Bot>();

        // Create the Bot UI
        botResponseText = CreateBotResponseText();

        // Set properties of Bot GameObject
        Bot.Instance.botMaterial = new Material(Shader.Find("Diffuse"));
        botObjInScene.GetComponent<Renderer>().material = Bot.Instance.botMaterial;
        Bot.Instance.botMaterial.color = Color.blue;
        botObjInScene.transform.position = new Vector3(0f, 2f, 10f);
        botObjInScene.tag = "BotTag";
    }

Lägg till följande metod som ansvarar för att skapa användargränssnittsobjektet i scenen och som representerar svaren från roboten:

    /// <summary>
    /// Spawns cursor for the Main Camera
    /// </summary>
    private TextMesh CreateBotResponseText()
    {
        // Create a sphere as new cursor
        GameObject textObject = new GameObject();
        textObject.transform.parent = Bot.Instance.transform;
        textObject.transform.localPosition = new Vector3(0,1,0);

        // Resize the new cursor
        textObject.transform.localScale = new Vector3(0.1f, 0.1f, 0.1f);

        // Creating the text of the Label
        TextMesh textMesh = textObject.AddComponent<TextMesh>();
        textMesh.anchor = TextAnchor.MiddleCenter;
        textMesh.alignment = TextAlignment.Center;
        textMesh.fontSize = 50;
        textMesh.text = "Hi there, tap on me and I will start listening.";

        return textMesh;
    }

Se till att spara ändringarna i Visual Studio innan du återvänder till Unity.
Dra Skriptet SceneOrganiser från mappen Skript till huvudkameran i Unity-redigeraren. Komponenten Scenorganisering bör nu visas på huvudkameraobjektet, som visas i bilden nedan.

Kapitel 13 – Innan du skapar

För att utföra ett grundligt test av ditt program måste du läsa in det separat på HoloLens. Innan du gör det kontrollerar du att:

Alla inställningar som anges i kapitel 4 är korrekt inställda.
Skriptet SceneOrganiser är kopplat till main camera-objektet .
I klassen Bot kontrollerar du att du har infogat robothemlighetsnyckeln i botSecret-variabeln.

Kapitel 14 – Kompilering och separat inläsning till HoloLens

Allt som behövs för Unity-avsnittet i det här projektet har nu slutförts, så det är dags att bygga det från Unity.

Gå till Bygginställningar, Inställningar för filbygge > ....
I fönstret Bygginställningar klickar du på Skapa.
Om inte redan markerar du Unity C#-projekt.
Klicka på Skapa. Unity startar ett Istraživač datoteka fönster där du behöver skapa och väljer sedan en mapp som appen ska byggas in i. Skapa mappen nu och ge den namnet App. Klicka sedan på Välj mapp med appmappen markerad.
Unity börjar skapa projektet i mappen App .
När Unity har byggt klart (det kan ta lite tid) öppnas ett Istraživač datoteka fönster på platsen för bygget (kontrollera aktivitetsfältet eftersom det kanske inte alltid visas ovanför dina fönster, men meddelar dig om att ett nytt fönster har lagts till).

Kapitel 15 – Distribuera till HoloLens

Så här distribuerar du på HoloLens:

Du behöver IP-adressen för dina HoloLens (för fjärrdistribution) och för att säkerställa att HoloLens är i utvecklarläge. Så här gör du:
1. Öppna inställningarna när du använder HoloLens.
2. Gå till Avancerade alternativ för nätverks- och Internet-Wi-Fi > >
3. Observera IPv4-adressen.
4. Gå sedan tillbaka till Inställningar och sedan till Uppdatera och säkerhet > för utvecklare
5. Ange utvecklarläge på.
Gå till din nya Unity-version (appmappen) och öppna lösningsfilen med Visual Studio.
I Lösningskonfiguration väljer du Felsök.
I Lösningsplattformen väljer du x86, Fjärrdator.
Gå till menyn Skapa och klicka på Distribuera lösning för att separat läsa in programmet till dina HoloLens.
Din app bör nu visas i listan över installerade appar på HoloLens, redo att startas!

Kommentar

Om du vill distribuera till ett uppslukande headset ställer du in Lösningsplattformen på Lokal dator och ställer in konfigurationen på Felsökning med x86 som plattform. Distribuera sedan till den lokala datorn med hjälp av menyn Skapa och välj Distribuera lösning.

Kapitel 16 – Använda programmet på HoloLens

När du har startat programmet ser du roboten som en blå sfär framför dig.
Använd tryckgesten medan du tittar på sfären för att initiera en konversation.
Vänta tills konversationen startas (Användargränssnittet visar ett meddelande när det händer). När du har fått introduktionsmeddelandet från roboten trycker du igen på roboten så att den blir röd och börjar lyssna på din röst.
När du slutar prata skickar programmet meddelandet till roboten och du får ett svar som visas i användargränssnittet.
Upprepa processen för att skicka fler meddelanden till roboten (du måste trycka varje gång du vill känna av ett meddelande).

Den här konversationen visar hur roboten kan behålla information (ditt namn) samtidigt som den tillhandahåller känd information (till exempel de objekt som finns i lager).

Några frågor att ställa till roboten:

what do you sell? 

how much are umbrellas?

how much are raincoats?

Ditt färdiga webbappsrobotprogram (v4)

Grattis, du har skapat en mixed reality-app som utnyttjar Azure Web App Bot, Microsoft Bot Framework v4.

Slutprodukt

Bonusövningar

Övning 1

Konversationsstrukturen i det här labbet är mycket grundläggande. Använd Microsoft LUIS för att ge din robot funktioner för förståelse av naturligt språk.

Övning 2

I det här exemplet ingår inte att avsluta en konversation och starta om en ny. Om du vill slutföra robotfunktionen kan du försöka implementera stängning av konversationen.

Dela via

HoloLens (första generationen) och Azure 312: Robotintegrering

Stöd för enheter

Förutsättningar

Innan du börjar

Kapitel 1 – Skapa robotprogrammet

Kapitel 2 – Skapa Azure Bot Service

Kapitel 3 – Publicera roboten till Azure Web App Bot Service

Kapitel 4 – Konfigurera Unity-projektet

Kapitel 5 – Kamerainstallation

Kapitel 6 – Importera Newtonsoft-biblioteket

Kapitel 7 – Skapa BotTag

Kapitel 8 – Skapa klassen BotObjects

Kapitel 9 – Skapa klassen GazeInput

Kapitel 10 – Skapa robotklassen

Kapitel 11 – Skapa klassen Interaktioner

Kapitel 12 – Skapa klassen SceneOrganiser

Kapitel 13 – Innan du skapar

Kapitel 14 – Kompilering och separat inläsning till HoloLens

Kapitel 15 – Distribuera till HoloLens

Kapitel 16 – Använda programmet på HoloLens

Några frågor att ställa till roboten:

Ditt färdiga webbappsrobotprogram (v4)

Bonusövningar

Övning 1

Övning 2

Ytterligare resurser