Dela via

Perceptionssimulering

  • Artikel

Vill du skapa ett automatiserat test för din app? Vill du att dina tester ska gå längre än enhetstestning på komponentnivå och verkligen träna appen från slutpunkt till slutpunkt? Perception Simulering är vad du letar efter. Biblioteket för perceptionssimulering skickar indata från människor och världen till din app så att du kan automatisera dina tester. Du kan till exempel simulera indata för en människa som ser till en specifik, repeterbar position och sedan använda en gest eller rörelsestyrenhet.

Perception Simulation kan skicka simulerade indata som denna till en fysisk HoloLens, HoloLens-emulatorn (första generationen), HoloLens 2-emulatorn eller en dator med Mixed Reality-portalen installerad. Perception Simulation kringgår livesensorerna på en Mixed Reality-enhet och skickar simulerade indata till program som körs på enheten. Program får dessa indatahändelser via samma API:er som de alltid använder och kan inte se skillnaden mellan att köra med verkliga sensorer jämfört med perceptionssimulering. Perception Simulation är samma teknik som används av HoloLens-emulatorerna för att skicka simulerade indata till den virtuella HoloLens-datorn.

Börja med att skapa ett IPerceptionSimulationManager-objekt för att börja använda simulering i koden. Från det objektet kan du utfärda kommandon för att styra egenskaperna för en simulerad "människa", inklusive huvudposition, handposition och gester. Du kan också aktivera och ändra rörelsestyrenheter.

Konfigurera ett Visual Studio-projekt för perceptionssimulering

  1. Installera HoloLens-emulatorn på utvecklingsdatorn. Emulatorn innehåller de bibliotek som du använder för perceptionssimulering.

  2. Skapa ett nytt Visual Studio C#-skrivbordsprojekt (ett konsolprojekt fungerar bra för att komma igång).

  3. Lägg till följande binärfiler i projektet som referenser (Project-Add-Reference>>...). Du hittar dem i %ProgramFiles(x86)%\Microsoft XDE\(version), till exempel %ProgramFiles(x86)%\Microsoft XDE\10.0.18362.0 för HoloLens 2-emulatorn.

    Kommentar

    Även om binärfilerna ingår i HoloLens 2-emulatorn fungerar de även för Windows Mixed Reality på skrivbordet.)

    a. PerceptionSimulationManager.Interop.dll – Hanterad C#-omslutning för perceptionssimulering.
    b. PerceptionSimulationRest.dll – Bibliotek för att konfigurera en kommunikationskanal för web-socket till HoloLens eller emulatorn.
    c. SimulationStream.Interop.dll – Delade typer för simulering.

  4. Lägg till implementeringsbinär PerceptionSimulationManager.dll i projektet

    a. Lägg först till den som binär i projektet (Project-Add-Existing>> Item...). Spara den som en länk så att den inte kopieras till projektkällans mapp.
    Lägg till PerceptionSimulationManager.dll i projektet som en länk

    b. Kontrollera sedan att den kopieras till utdatamappen när den skapas. Detta finns i egenskapsbladet för binärfilen.
    Markera PerceptionSimulationManager.dll som ska kopieras till utdatakatalogen

  5. Ställ in din aktiva lösningsplattform på x64. (Använd Configuration Manager för att skapa en plattformspost för x64 om det inte redan finns en.)

Skapa ett IPerceptionSimulation Manager-objekt

För att styra simuleringen utfärdar du uppdateringar av objekt som hämtats från ett IPerceptionSimulationManager-objekt. Det första steget är att hämta objektet och ansluta det till målenheten eller emulatorn. Du kan hämta IP-adressen för din emulator genom att klicka på knappen Enhetsportal i verktygsfältet

Ikonen Öppna enhetsportalenÖppna enhetsportalen: Öppna Windows-enhetsportalen för HoloLens-operativsystemet i emulatorn. För Windows Mixed Reality kan detta hämtas i appen Inställningar under "Uppdatera & säkerhet" och sedan "För utvecklare" i avsnittet "Anslut med:" under "Aktivera enhetsportal". Observera både IP-adressen och porten.

Först anropar du RestSimulationStreamSink.Create för att hämta ett RestSimulationStreamSink-objekt. Det här är målenheten eller emulatorn som du ska kontrollera över en http-anslutning. Dina kommandon skickas till och hanteras av Windows-enhetsportalen som körs på enheten eller emulatorn. De fyra parametrarna du behöver för att skapa ett objekt är:

  • Uri uri – IP-adress för målenheten (t.ex. "https://123.123.123.123" eller "https://123.123.123.123:50080")
  • System.Net.NetworkCredential-autentiseringsuppgifter – Användarnamn/lösenord för att ansluta till Windows-enhetsportalen på målenheten eller emulatorn. Om du ansluter till emulatorn via dess lokala adress (t.ex. 168... *) på samma dator godkänns alla autentiseringsuppgifter.
  • bool normal – Sant för normal prioritet, falskt för låg prioritet. Du vill vanligtvis ställa in detta på sant för testscenarier, vilket gör att testet kan ta kontroll. Emulatorn och Windows Mixed Reality-simuleringen använder anslutningar med låg prioritet. Om testet också använder en anslutning med låg prioritet har den senast etablerade anslutningen kontroll.
  • System.Threading.CancellationToken-token – Token för att avbryta asynkroniseringsåtgärden.

För det andra skapar du IPerceptionSimulationManager. Det här är det objekt som du använder för att styra simuleringen. Detta måste också göras i en asynkron metod.

Kontrollera den simulerade människan

En IPerceptionSimulationManager har en mänsklig egenskap som returnerar ett ISimulatedHuman-objekt. Om du vill kontrollera den simulerade människan utför du åtgärder på det här objektet. Till exempel:

manager.Human.Move(new Vector3(0.1f, 0.0f, 0.0f))

Grundläggande C#-exempelkonsolprogram

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.PerceptionSimulation;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Task.Run(async () =>
            {
                RestSimulationStreamSink sink = null;
                CancellationToken token = new System.Threading.CancellationToken();

                try
                {
                    sink = await RestSimulationStreamSink.Create(
                        // use the IP address for your device/emulator
                        new Uri("https://169.254.227.115"),
                        // no credentials are needed for the emulator
                        new System.Net.NetworkCredential("", ""),
                        // normal priorty
                        true,
                        // cancel token
                        token);

                    IPerceptionSimulationManager manager = PerceptionSimulationManager.CreatePerceptionSimulationManager(sink);
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                }

                // Always close the sink to return control to the previous application.
                if (sink != null)
                {
                    await sink.Close(token);
                }
            });

            // If main exits, the process exits.  
            Console.WriteLine("Press any key to exit...");
            Console.ReadLine();
        }
    }
}

Utökat C#-exempelkonsolprogram

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.PerceptionSimulation;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            RestSimulationStreamSink sink = null;
            CancellationToken token = new System.Threading.CancellationToken();

            Task.Run(async () =>
            {
                try
                {
                    sink = await RestSimulationStreamSink.Create(
                        // use the IP address for your device/emulator
                        new Uri("https://169.254.227.115"),
                        // no credentials are needed for the emulator
                        new System.Net.NetworkCredential("", ""),
                        // normal priorty
                        true,
                        // cancel token
                        token);

                    IPerceptionSimulationManager manager = PerceptionSimulationManager.CreatePerceptionSimulationManager(sink);

                    // Now, we'll simulate a sequence of actions.
                    // Sleeps in-between each action give time to the system
                    // to be able to properly react.
                    // This is just an example. A proper automated test should verify
                    // that the app has behaved correctly
                    // before proceeding to the next step, instead of using Sleeps.

                    // Activate the right hand
                    manager.Human.RightHand.Activated = true;

                    // Simulate Bloom gesture, which should cause Shell to disappear
                    manager.Human.RightHand.PerformGesture(SimulatedGesture.Home);
                    Thread.Sleep(2000);

                    // Simulate Bloom gesture again... this time, Shell should reappear
                    manager.Human.RightHand.PerformGesture(SimulatedGesture.Home);
                    Thread.Sleep(2000);

                    // Simulate a Head rotation down around the X axis
                    // This should cause gaze to aim about the center of the screen
                    manager.Human.Head.Rotate(new Rotation3(0.04f, 0.0f, 0.0f));
                    Thread.Sleep(300);

                    // Simulate a finger press & release
                    // Should cause a tap on the center tile, thus launching it
                    manager.Human.RightHand.PerformGesture(SimulatedGesture.FingerPressed);
                    Thread.Sleep(300);
                    manager.Human.RightHand.PerformGesture(SimulatedGesture.FingerReleased);
                    Thread.Sleep(2000);

                    // Simulate a second finger press & release
                    // Should activate the app that was launched when the center tile was clicked
                    manager.Human.RightHand.PerformGesture(SimulatedGesture.FingerPressed);
                    Thread.Sleep(300);
                    manager.Human.RightHand.PerformGesture(SimulatedGesture.FingerReleased);
                    Thread.Sleep(5000);

                    // Simulate a Head rotation towards the upper right corner
                    manager.Human.Head.Rotate(new Rotation3(-0.14f, 0.17f, 0.0f));
                    Thread.Sleep(300);

                    // Simulate a third finger press & release
                    // Should press the Remove button on the app
                    manager.Human.RightHand.PerformGesture(SimulatedGesture.FingerPressed);
                    Thread.Sleep(300);
                    manager.Human.RightHand.PerformGesture(SimulatedGesture.FingerReleased);
                    Thread.Sleep(2000);

                    // Simulate Bloom gesture again... bringing the Shell back once more
                    manager.Human.RightHand.PerformGesture(SimulatedGesture.Home);
                    Thread.Sleep(2000);
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                }
            });

            // If main exits, the process exits.  
            Console.WriteLine("Press any key to exit...");
            Console.ReadLine();

            // Always close the sink to return control to the previous application.
            if (sink != null)
            {
                sink.Close(token);
            }
        }
    }
}

Obs! på 6 DOF-styrenheter

Innan du anropar några egenskaper för metoder på en simulerad 6-DOF-styrenhet måste du aktivera styrenheten. Om du inte gör det resulterar det i ett undantag. Från och med Maj 2019-uppdatering för Windows 10 kan simulerade 6-DOF-styrenheter installeras och aktiveras genom att ange statusegenskapen på objektet ISimulatedSixDofController till SimulatedSixDofControllerStatus.Active. I Oktober 2018-uppdatering för Windows 10 och tidigare måste du installera en simulerad 6-DOF-styrenhet separat först genom att anropa verktyget PerceptionSimulationDevice i mappen \Windows\System32. Användningen av det här verktyget är följande:

    PerceptionSimulationDevice.exe <action> 6dof <instance>

Till exempel

    PerceptionSimulationDevice.exe i 6dof 1

Åtgärder som stöds är:

  • i = installera
  • q = fråga
  • r = remove

Instanser som stöds är:

  • 1 = den vänstra 6-DOF-styrenheten
  • 2 = rätt 6-DOF-styrenhet

Processens slutkod indikerar lyckat (noll returvärde) eller fel (ett returvärde som inte är noll). När du använder åtgärden "q" för att fråga om en kontrollant är installerad blir returvärdet noll (0) om kontrollanten inte redan är installerad eller en (1) om kontrollanten är installerad.

När du tar bort en kontrollant på Oktober 2018-uppdatering för Windows 10 eller tidigare anger du dess status till Av via API:et först och anropar sedan verktyget PerceptionSimulationDevice.

Det här verktyget måste köras som administratör.

API-referens

Microsoft.PerceptionSimulation.SimulatedDeviceType

Beskriver en simulerad enhetstyp

public enum SimulatedDeviceType
{
    Reference = 0
}

Microsoft.PerceptionSimulation.SimulatedDeviceType.Reference

En fiktiv referensenhet, standardvärdet för PerceptionSimulationManager

Microsoft.PerceptionSimulation.HeadTrackerMode

Beskriver ett huvudspårarläge

public enum HeadTrackerMode
{
    Default = 0,
    Orientation = 1,
    Position = 2
}

Microsoft.PerceptionSimulation.HeadTrackerMode.Default

Standardhuvudspårning. Det innebär att systemet kan välja det bästa huvudspårningsläget baserat på körningsvillkor.

Microsoft.PerceptionSimulation.HeadTrackerMode.Orientation

Endast huvudspårning för orientering. Det innebär att den spårade positionen kanske inte är tillförlitlig och att vissa funktioner som är beroende av huvudposition kanske inte är tillgängliga.

Microsoft.PerceptionSimulation.HeadTrackerMode.Position

Positioneringshuvudspårning. Det innebär att den spårade huvudpositionen och orienteringen båda är tillförlitliga

Microsoft.PerceptionSimulation.SimulatedGesture

Beskriver en simulerad gest

public enum SimulatedGesture
{
    None = 0,
    FingerPressed = 1,
    FingerReleased = 2,
    Home = 4,
    Max = Home
}

Microsoft.PerceptionSimulation.SimulatedGesture.None

Ett sentinel-värde som används för att ange inga gester.

Microsoft.PerceptionSimulation.SimulatedGesture.FingerPressed

En fingertryckt gest.

Microsoft.PerceptionSimulation.SimulatedGesture.FingerReleased

Ett finger släppte gest.

Microsoft.PerceptionSimulation.SimulatedGesture.Home

Hem-/systemgesten.

Microsoft.PerceptionSimulation.SimulatedGesture.Max

Den maximala giltiga gesten.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus

Möjliga tillstånd för en simulerad 6-DOF-styrenhet.

public enum SimulatedSixDofControllerStatus
{
    Off = 0,
    Active = 1,
    TrackingLost = 2,
}

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Off

6-DOF-styrenheten är avstängd.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Active

6-DOF-styrenheten är aktiverad och spårad.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.TrackingLost

6-DOF-styrenheten är aktiverad men kan inte spåras.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton

Knapparna som stöds på en simulerad 6-DOF-styrenhet.

public enum SimulatedSixDofControllerButton
{
    None = 0,
    Home = 1,
    Menu = 2,
    Grip = 4,
    TouchpadPress = 8,
    Select = 16,
    TouchpadTouch = 32,
    Thumbstick = 64,
    Max = Thumbstick
}

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.None

Ett sentinel-värde som används för att ange inga knappar.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Home

Knappen Start trycks in.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Menu

Knappen Meny trycks in.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Grip

Grip-knappen trycks in.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.TouchpadPress

Pekplattan trycks på.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Select

Knappen Välj trycks på.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.TouchpadTouch

TouchPad-enheten är vidrörd.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Thumbstick

Tumsticken trycks in.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Max

Den maximala giltiga knappen.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState

Kalibreringstillståndet för de simulerade ögonen

public enum SimulatedGesture
{
    Unavailable = 0,
    Ready = 1,
    Configuring = 2,
    UserCalibrationNeeded = 3
}

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Unavailable

Ögonkalibreringen är inte tillgänglig.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Ready

Ögonen har kalibrerats. Detta är standardvärdet.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Configuring

Ögonen kalibreras.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.UserCalibrationNeededed

Ögonen måste kalibreras.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy

Spårningsnoggrannheten hos en led i handen.

public enum SimulatedHandJointTrackingAccuracy
{
    Unavailable = 0,
    Approximate = 1,
    Visible = 2
}

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Unavailable

Leden spåras inte.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Approximate

Den gemensamma positionen härleds.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Visible

Leden är helt spårad.

Microsoft.PerceptionSimulation.SimulatedHandPose

Spårningsnoggrannheten hos en led i handen.

public enum SimulatedHandPose
{
    Closed = 0,
    Open = 1,
    Point = 2,
    Pinch = 3,
    Max = Pinch
}

Microsoft.PerceptionSimulation.SimulatedHandPose.Closed

Handens fingerfogar är konfigurerade för att återspegla en sluten pose.

Microsoft.PerceptionSimulation.SimulatedHandPose.Open

Handens fingerfogar är konfigurerade för att återspegla en öppen pose.

Microsoft.PerceptionSimulation.SimulatedHandPose.Point

Handens fingerfogar är konfigurerade för att återspegla en pekposition.

Microsoft.PerceptionSimulation.SimulatedHandPose.Pinch

Handens fingerfogar är konfigurerade för att återspegla en klämande pose.

Microsoft.PerceptionSimulation.SimulatedHandPose.Max

Det maximala giltiga värdet för SimulatedHandPose.

Microsoft.PerceptionSimulation.PlaybackState

Beskriver tillståndet för en uppspelning.

public enum PlaybackState
{
    Stopped = 0,
    Playing = 1,
    Paused = 2,
    End = 3,
}

Microsoft.PerceptionSimulation.PlaybackState.Stopped

Inspelningen är för närvarande stoppad och klar för uppspelning.

Microsoft.PerceptionSimulation.PlaybackState.Playing

Inspelningen spelas för närvarande upp.

Microsoft.PerceptionSimulation.PlaybackState.Paused

Inspelningen är för närvarande pausad.

Microsoft.PerceptionSimulation.PlaybackState.End

Inspelningen har nått slutet.

Microsoft.PerceptionSimulation.Vector3

Beskriver en vektor med tre komponenter, som kan beskriva en punkt eller en vektor i 3D-utrymme.

public struct Vector3
{
    public float X;
    public float Y;
    public float Z;
    public Vector3(float x, float y, float z);
}

Microsoft.PerceptionSimulation.Vector3.X

X-komponenten i vektorn.

Microsoft.PerceptionSimulation.Vector3.Y

Y-komponenten i vektorn.

Microsoft.PerceptionSimulation.Vector3.Z

Z-komponenten i vektorn.

Microsoft.PerceptionSimulation.Vector3.#ctor(System.Single, System.Single, System.Single, System.Single)

Skapa en ny Vector3.

Parametrar

  • x – X-komponenten i vektorn.
  • y – y-komponenten i vektorn.
  • z – Z-komponenten i vektorn.

Microsoft.PerceptionSimulation.Rotation3

Beskriver en rotation av tre komponenter.

public struct Rotation3
{
    public float Pitch;
    public float Yaw;
    public float Roll;
    public Rotation3(float pitch, float yaw, float roll);
}

Microsoft.PerceptionSimulation.Rotation3.Pitch

Pitch-komponenten i rotationen, nedåt runt X-axeln.

Microsoft.PerceptionSimulation.Rotation3.Yaw

Yaw-komponenten i Rotation, precis runt Y-axeln.

Microsoft.PerceptionSimulation.Rotation3.Roll

Roll-komponenten i Rotation, precis runt Z-axeln.

Microsoft.PerceptionSimulation.Rotation3.#ctor(System.Single,System.Single,System.Single)

Konstruera en ny Rotation3.

Parametrar

  • pitch – Rotationens tonhöjdskomponent.
  • yaw - Yaw komponenten i Rotation.
  • roll – Rotationens rollkomponent.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration

Beskriver konfigurationen av en joint på en simulerad hand.

public struct SimulatedHandJointConfiguration
{
    public Vector3 Position;
    public Rotation3 Rotation;
    public SimulatedHandJointTrackingAccuracy TrackingAccuracy;
}

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.Position

Ledens position.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.Rotation

Rotationen av leden.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.TrackingAccuracy

Ledens spårningsnoggrannhet.

Microsoft.PerceptionSimulation.Frustum

Beskriver en vy frustum, som vanligtvis används av en kamera.

public struct Frustum
{
    float Near;
    float Far;
    float FieldOfView;
    float AspectRatio;
}

Microsoft.PerceptionSimulation.Frustum.Near

Det minsta avstånd som finns i frustum.

Microsoft.PerceptionSimulation.Frustum.Far

Det maximala avståndet som finns i frustum.

Microsoft.PerceptionSimulation.Frustum.FieldOfView

Det vågräta synfältet för frustum, i radianer (mindre än PI).

Microsoft.PerceptionSimulation.Frustum.AspectRatio

Förhållandet mellan det vågräta synfältet och det lodräta visningsfältet.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration

Beskriver konfigurationen av det simulerade headsetets skärm.

public struct SimulatedDisplayConfiguration
{
    public Vector3 LeftEyePosition;
    public Rotation3 LeftEyeRotation;
    public Vector3 RightEyePosition;
    public Rotation3 RightEyeRotation;
    public float Ipd;
    public bool ApplyEyeTransforms;
    public bool ApplyIpd;
}

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.LeftEyePosition

Transformering från mitten av huvudet till det vänstra ögat för stereorendering.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.LeftEyeRotation

Rotationen av det vänstra ögat för stereorendering.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyePosition

Omvandlingen från mitten av huvudet till det högra ögat för stereorendering.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyeRotation

Rotationen av det högra ögat för stereorendering.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.Ipd

Ipd-värdet som rapporteras av systemet för stereorendering.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyEyeTransforms

Om värdena som anges för vänster- och högerögatransformeringar ska betraktas som giltiga och tillämpas på det system som körs.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyIpd

Om värdet som anges för Ipd ska betraktas som giltigt och tillämpas på det system som körs.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager

Rot för att generera paket som används för att styra en enhet.

public interface IPerceptionSimulationManager
{   
    ISimulatedDevice Device { get; }
    ISimulatedHuman Human { get; }
    void Reset();
}

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Device

Hämta det simulerade enhetsobjektet som tolkar den simulerade människan och den simulerade världen.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Human

Hämta objektet som styr den simulerade människan.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Reset

Återställer simuleringen till standardtillståndet.

Microsoft.PerceptionSimulation.ISimulatedDevice

Gränssnitt som beskriver enheten, som tolkar den simulerade världen och den simulerade mänskliga

public interface ISimulatedDevice
{
    ISimulatedHeadTracker HeadTracker { get; }
    ISimulatedHandTracker HandTracker { get; }
    void SetSimulatedDeviceType(SimulatedDeviceType type);
}

Microsoft.PerceptionSimulation.ISimulatedDevice.HeadTracker

Hämta huvudspåraren från den simulerade enheten.

Microsoft.PerceptionSimulation.ISimulatedDevice.HandTracker

Hämta handspåraren från den simulerade enheten.

Microsoft.PerceptionSimulation.ISimulatedDevice.SetSimulatedDeviceType(Microsoft.PerceptionSimulation.SimulatedDeviceType)

Ange egenskaperna för den simulerade enheten så att den matchar den angivna enhetstypen.

Parametrar

  • type – Den nya typen av simulerad enhet

Microsoft.PerceptionSimulation.ISimulatedDevice2

Ytterligare egenskaper är tillgängliga genom att casta ISimulatedDevice till ISimulatedDevice2

public interface ISimulatedDevice2
{
    bool IsUserPresent { [return: MarshalAs(UnmanagedType.Bool)] get; [param: MarshalAs(UnmanagedType.Bool)] set; }
    SimulatedDisplayConfiguration DisplayConfiguration { get; set; }

};

Microsoft.PerceptionSimulation.ISimulatedDevice2.IsUserPresent

Hämta eller ange om den simulerade människan aktivt använder headsetet.

Microsoft.PerceptionSimulation.ISimulatedDevice2.DisplayConfiguration

Hämta eller ange egenskaperna för den simulerade visningen.

Microsoft.PerceptionSimulation.ISimulatedHeadTracker

Gränssnitt som beskriver den del av den simulerade enheten som spårar huvudet på den simulerade människan.

public interface ISimulatedHeadTracker
{
    HeadTrackerMode HeadTrackerMode { get; set; }
};

Microsoft.PerceptionSimulation.ISimulatedHeadTracker.HeadTrackerMode

Hämtar och anger aktuellt huvudspårarläge.

Microsoft.PerceptionSimulation.ISimulatedHandTracker

Gränssnitt som beskriver den del av den simulerade enheten som spårar händerna på den simulerade människan

public interface ISimulatedHandTracker
{
    Vector3 WorldPosition { get; }
    Vector3 Position { get; set; }
    float Pitch { get; set; }
    bool FrustumIgnored { [return: MarshalAs(UnmanagedType.Bool)] get; [param: MarshalAs(UnmanagedType.Bool)] set; }
    Frustum Frustum { get; set; }
}

Microsoft.PerceptionSimulation.ISimulatedHandTracker.WorldPosition

Hämta nodens position med relation till världen, i meter.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Position

Hämta och ange positionen för den simulerade handspåraren i förhållande till huvudets mittpunkt.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Pitch

Hämta och ange den simulerade handspårarens nedåtgående tonhöjd.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.FrustumIgnored

Hämta och ange om frustum för den simulerade handspåraren ignoreras. När de ignoreras är båda händerna alltid synliga. När inte ignoreras (standard) händer är endast synliga när de är inom frustum hand tracker.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Frustum

Hämta och ange de frustumegenskaper som används för att avgöra om händerna är synliga för den simulerade handspåraren.

Microsoft.PerceptionSimulation.ISimulatedHuman

Gränssnitt på översta nivån för att styra den simulerade människan.

public interface ISimulatedHuman 
{
    Vector3 WorldPosition { get; set; }
    float Direction { get; set; }
    float Height { get; set; }
    ISimulatedHand LeftHand { get; }
    ISimulatedHand RightHand { get; }
    ISimulatedHead Head { get; }s
    void Move(Vector3 translation);
    void Rotate(float radians);
}

Microsoft.PerceptionSimulation.ISimulatedHuman.WorldPosition

Hämta och ange nodens position i förhållande till världen, i meter. Positionen motsvarar en punkt i mitten av människans fötter.

Microsoft.PerceptionSimulation.ISimulatedHuman.Direction

Hämta och ange riktningen för de simulerade mänskliga ansiktena i världen. 0 radianer vetter nedåt på den negativa Z-axeln. Positiva radianer roterar medsols om Y-axeln.

Microsoft.PerceptionSimulation.ISimulatedHuman.Height

Hämta och ange höjden på den simulerade människan i meter.

Microsoft.PerceptionSimulation.ISimulatedHuman.LeftHand

Hämta den simulerade människans vänstra hand.

Microsoft.PerceptionSimulation.ISimulatedHuman.RightHand

Hämta den simulerade människans högra hand.

Microsoft.PerceptionSimulation.ISimulatedHuman.Head

Hämta huvudet på den simulerade människan.

Microsoft.PerceptionSimulation.ISimulatedHuman.Move(Microsoft.PerceptionSimulation.Vector3)

Flytta den simulerade människan i förhållande till dess aktuella position i meter.

Parametrar

  • translation – Översättningen som ska flyttas i förhållande till aktuell position.

Microsoft.PerceptionSimulation.ISimulatedHuman.Rotate(System.Single)

Rotera den simulerade människan i förhållande till dess aktuella riktning, medsols om Y-axeln

Parametrar

  • radianer – Mängden som ska roteras runt Y-axeln.

Microsoft.PerceptionSimulation.ISimulatedHuman2

Ytterligare egenskaper är tillgängliga genom att casta ISimulatedHuman till ISimulatedHuman2

public interface ISimulatedHuman2
{
    /* New members in addition to those available on ISimulatedHuman */
    ISimulatedSixDofController LeftController { get; }
    ISimulatedSixDofController RightController { get; }
}

Microsoft.PerceptionSimulation.ISimulatedHuman2.LeftController

Hämta den vänstra 6-DOF-styrenheten.

Microsoft.PerceptionSimulation.ISimulatedHuman2.RightController

Hämta rätt 6-DOF-styrenhet.

Microsoft.PerceptionSimulation.ISimulatedHand

Gränssnitt som beskriver en hand av den simulerade människan

public interface ISimulatedHand
{
    Vector3 WorldPosition { get; }
    Vector3 Position { get; set; }
    bool Activated { [return: MarshalAs(UnmanagedType.Bool)] get; [param: MarshalAs(UnmanagedType.Bool)] set; }
    bool Visible { [return: MarshalAs(UnmanagedType.Bool)] get; }
    void EnsureVisible();
    void Move(Vector3 translation);
    void PerformGesture(SimulatedGesture gesture);
}

Microsoft.PerceptionSimulation.ISimulatedHand.WorldPosition

Hämta nodens position med relation till världen, i meter.

Microsoft.PerceptionSimulation.ISimulatedHand.Position

Hämta och ange positionen för den simulerade handen i förhållande till människan, i meter.

Microsoft.PerceptionSimulation.ISimulatedHand.Activated

Hämta och ange om handen för närvarande är aktiverad.

Microsoft.PerceptionSimulation.ISimulatedHand.Visible

Hämta om handen för närvarande är synlig för SimulatedDevice (dvs. om den är i en position som kan identifieras av HandTracker).

Microsoft.PerceptionSimulation.ISimulatedHand.EnsureVisible

Flytta handen så att den är synlig för SimulatedDevice.

Microsoft.PerceptionSimulation.ISimulatedHand.Move(Microsoft.PerceptionSimulation.Vector3)

Flytta positionen för den simulerade handen i förhållande till dess aktuella position i meter.

Parametrar

  • translation – Mängden som ska översättas för den simulerade handen.

Microsoft.PerceptionSimulation.ISimulatedHand.PerformGesture(Microsoft.PerceptionSimulation.SimulatedGesture)

Utför en gest med hjälp av den simulerade handen. Det identifieras bara av systemet om handen är aktiverad.

Parametrar

  • gest – Gesten som ska utföras.

Microsoft.PerceptionSimulation.ISimulatedHand2

Ytterligare egenskaper är tillgängliga genom att casta en ISimulatedHand till ISimulatedHand2.

public interface ISimulatedHand2
{
    /* New members in addition to those available on ISimulatedHand */
    Rotation3 Orientation { get; set; }
}

Microsoft.PerceptionSimulation.ISimulatedHand2.Orientation

Hämta eller ange rotationen för den simulerade handen. Positiva radianer roterar medsols när de tittar längs axeln.

Microsoft.PerceptionSimulation.ISimulatedHand3

Ytterligare egenskaper är tillgängliga genom att casta en ISimulatedHand till ISimulatedHand3

public interface ISimulatedHand3
{
    /* New members in addition to those available on ISimulatedHand and ISimulatedHand2 */
    GetJointConfiguration(SimulatedHandJoint joint, out SimulatedHandJointConfiguration jointConfiguration);
    SetJointConfiguration(SimulatedHandJoint joint, SimulatedHandJointConfiguration jointConfiguration);
    SetHandPose(SimulatedHandPose pose, bool animate);
}

Microsoft.PerceptionSimulation.ISimulatedHand3.GetJointConfiguration

Hämta den gemensamma konfigurationen för den angivna jointen.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetJointConfiguration

Ange den gemensamma konfigurationen för den angivna jointen.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetHandPose

Ställ in handen på en känd pose med en valfri flagga som animera. Obs! Animera resulterar inte i leder som omedelbart återspeglar deras slutliga gemensamma konfigurationer.

Microsoft.PerceptionSimulation.ISimulatedHead

Gränssnitt som beskriver huvudet på den simulerade människan.

public interface ISimulatedHead
{
    Vector3 WorldPosition { get; }
    Rotation3 Rotation { get; set; }
    float Diameter { get; set; }
    void Rotate(Rotation3 rotation);
}

Microsoft.PerceptionSimulation.ISimulatedHead.WorldPosition

Hämta nodens position med relation till världen, i meter.

Microsoft.PerceptionSimulation.ISimulatedHead.Rotation

Hämta rotationen av det simulerade huvudet. Positiva radianer roterar medsols när de tittar längs axeln.

Microsoft.PerceptionSimulation.ISimulatedHead.Diameter

Hämta det simulerade huvudets diameter. Det här värdet används för att fastställa huvudets mittpunkt (rotationspunkt).

Microsoft.PerceptionSimulation.ISimulatedHead.Rotate(Microsoft.PerceptionSimulation.Rotation3)

Rotera det simulerade huvudet i förhållande till dess aktuella rotation. Positiva radianer roterar medsols när de tittar längs axeln.

Parametrar

  • rotation – mängden som ska roteras.

Microsoft.PerceptionSimulation.ISimulatedHead2

Ytterligare egenskaper är tillgängliga genom att casta en ISimulatedHead till ISimulatedHead2

public interface ISimulatedHead2
{
    /* New members in addition to those available on ISimulatedHead */
    ISimulatedEyes Eyes { get; }
}

Microsoft.PerceptionSimulation.ISimulatedHead2.Eyes

Hämta ögonen på den simulerade människan.

Microsoft.PerceptionSimulation.ISimulatedSixDofController

Gränssnitt som beskriver en 6-DOF-styrenhet som är associerad med den simulerade människan.

public interface ISimulatedSixDofController
{
    Vector3 WorldPosition { get; }
    SimulatedSixDofControllerStatus Status { get; set; }
    Vector3 Position { get; }
    Rotation3 Orientation { get; set; }
    void Move(Vector3 translation);
    void PressButton(SimulatedSixDofControllerButton button);
    void ReleaseButton(SimulatedSixDofControllerButton button);
    void GetTouchpadPosition(out float x, out float y);
    void SetTouchpadPosition(float x, float y);
}

Microsoft.PerceptionSimulation.ISimulatedSixDofController.WorldPosition

Hämta nodens position med relation till världen, i meter.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Status

Hämta eller ange kontrollantens aktuella tillstånd. Kontrollantens status måste anges till ett annat värde än Av innan några anrop för att flytta, rotera eller trycka på knapparna lyckas.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Position

Hämta eller ange positionen för den simulerade styrenheten i förhållande till människan, i meter.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Orientation

Hämta eller ange orienteringen för den simulerade styrenheten.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Move(Microsoft.PerceptionSimulation.Vector3)

Flytta positionen för den simulerade styrenheten i förhållande till dess aktuella position i meter.

Parametrar

  • translation – Mängden för att översätta den simulerade kontrollanten.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.PressButton(SimulatedSixDofControllerButton)

Tryck på en knapp på den simulerade styrenheten. Det identifieras endast av systemet om kontrollanten är aktiverad.

Parametrar

  • knapp – Knappen som ska tryckas på.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.ReleaseButton(SimulatedSixDofControllerButton)

Släpp en knapp på den simulerade styrenheten. Det identifieras endast av systemet om kontrollanten är aktiverad.

Parametrar

  • button – Knappen för att släppa.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.GetTouchpadPosition(out float, out float)

Hämta positionen för ett simulerat finger på den simulerade styrenhetens pekplatta.

Parametrar

  • x – Fingrets vågräta position.
  • y - Det lodräta läget för fingret.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.SetTouchpadPosition(float, float)

Ange positionen för ett simulerat finger på den simulerade styrenhetens pekplatta.

Parametrar

  • x – Fingrets vågräta position.
  • y - Det lodräta läget för fingret.

Microsoft.PerceptionSimulation.ISimulatedSixDofController2

Ytterligare egenskaper och metoder är tillgängliga genom att casta en ISimulatedSixDofController till ISimulatedSixDofController2

public interface ISimulatedSixDofController2
{
    /* New members in addition to those available on ISimulatedSixDofController */
    void GetThumbstickPosition(out float x, out float y);
    void SetThumbstickPosition(float x, float y);
    float BatteryLevel { get; set; }
}

Microsoft.PerceptionSimulation.ISimulatedSixDofController2.GetThumbstickPosition(out float, out float)

Hämta positionen för den simulerade tumsticken på den simulerade styrenheten.

Parametrar

  • x – Tumstickens vågräta position.
  • y - Tumstickans lodräta position.

Microsoft.PerceptionSimulation.ISimulatedSixDofController2.SetThumbstickPosition(float, float)

Ange positionen för den simulerade tumsticken på den simulerade styrenheten.

Parametrar

  • x – Tumstickens vågräta position.
  • y - Tumstickans lodräta position.

Microsoft.PerceptionSimulation.ISimulatedSixDofController2.BatteryLevel

Hämta eller ange batterinivån för den simulerade styrenheten. Värdet måste vara större än 0,0 och mindre än eller lika med 100,0.

Microsoft.PerceptionSimulation.ISimulatedEyes

Gränssnitt som beskriver ögonen på den simulerade människan.

public interface ISimulatedEyes
{
    Rotation3 Rotation { get; set; }
    void Rotate(Rotation3 rotation);
    SimulatedEyesCalibrationState CalibrationState { get; set; }
    Vector3 WorldPosition { get; }
}

Microsoft.PerceptionSimulation.ISimulatedEyes.Rotation

Hämta rotationen av simulerade ögon. Positiva radianer roterar medsols när de tittar längs axeln.

Microsoft.PerceptionSimulation.ISimulatedEyes.Rotate(Microsoft.PerceptionSimulation.Rotation3)

Rotera de simulerade ögonen i förhållande till dess aktuella rotation. Positiva radianer roterar medsols när de tittar längs axeln.

Parametrar

  • rotation – mängden som ska roteras.

Microsoft.PerceptionSimulation.ISimulatedEyes.CalibrationState

Hämtar eller anger kalibreringstillståndet för de simulerade ögonen.

Microsoft.PerceptionSimulation.ISimulatedEyes.WorldPosition

Hämta nodens position med relation till världen, i meter.

Microsoft.PerceptionSimulation.ISimulationRecording

Gränssnitt för att interagera med en enda inspelning som läses in för uppspelning.

public interface ISimulationRecording
{
    StreamDataTypes DataTypes { get; }
    PlaybackState State { get; }
    void Play();
    void Pause();
    void Seek(UInt64 ticks);
    void Stop();
};

Microsoft.PerceptionSimulation.ISimulationRecording.DataTypes

Hämtar listan över datatyper i inspelningen.

Microsoft.PerceptionSimulation.ISimulationRecording.State

Hämtar inspelningens aktuella tillstånd.

Microsoft.PerceptionSimulation.ISimulationRecording.Play

Starta uppspelningen. Om inspelningen pausas återupptas uppspelningen från den pausade platsen. om den stoppas startar uppspelningen i början. Om det redan spelas upp ignoreras det här anropet.

Microsoft.PerceptionSimulation.ISimulationRecording.Pause

Pausar uppspelningen på den aktuella platsen. Om inspelningen stoppas ignoreras anropet.

Microsoft.PerceptionSimulation.ISimulationRecording.Seek(System.UInt64)

Söker efter inspelningen till den angivna tiden (i intervallet 100 nanosekunder från början) och pausar på den platsen. Om tiden är längre än till slutet av inspelningen pausas den vid den sista bildrutan.

Parametrar

  • ticks – Den tid som du ska söka efter.

Microsoft.PerceptionSimulation.ISimulationRecording.Stop

Stoppar uppspelningen och återställer positionen till början.

Microsoft.PerceptionSimulation.ISimulationRecordingCallback

Gränssnitt för att ta emot tillståndsändringar under uppspelningen.

public interface ISimulationRecordingCallback
{
    void PlaybackStateChanged(PlaybackState newState);
};

Microsoft.PerceptionSimulation.ISimulationRecordingCallback.PlaybackStateChanged(Microsoft.PerceptionSimulation.PlaybackState)

Anropas när uppspelningstillståndet för ISimulationRecording har ändrats.

Parametrar

  • newState – det nya tillståndet för inspelningen.

Microsoft.PerceptionSimulation.PerceptionSimulationManager

Rotobjekt för att skapa perceptionssimuleringsobjekt.

public static class PerceptionSimulationManager
{
    public static IPerceptionSimulationManager CreatePerceptionSimulationManager(ISimulationStreamSink sink);
    public static ISimulationStreamSink CreatePerceptionSimulationRecording(string path);
    public static ISimulationRecording LoadPerceptionSimulationRecording(string path, ISimulationStreamSinkFactory factory);
    public static ISimulationRecording LoadPerceptionSimulationRecording(string path, ISimulationStreamSinkFactory factory, ISimulationRecordingCallback callback);

Microsoft.PerceptionSimulation.PerceptionSimulationManager.CreatePerceptionSimulationManager(Microsoft.PerceptionSimulation.ISimulationStreamSink)

Skapa på objekt för att generera simulerade paket och leverera dem till den angivna mottagaren.

Parametrar

  • sink – den mottagare som tar emot alla genererade paket.

Returvärde

Den skapade chefen.

Microsoft.PerceptionSimulation.PerceptionSimulationManager.CreatePerceptionSimulationRecording(System.String)

Skapa en mottagare som lagrar alla mottagna paket i en fil på den angivna sökvägen.

Parametrar

  • path – sökvägen till filen som ska skapas.

Returvärde

Den skapade mottagaren.

Microsoft.PerceptionSimulation.PerceptionSimulationManager.LoadPerceptionSimulationRecording(System.String, Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory)

Läs in en inspelning från den angivna filen.

Parametrar

  • path – sökvägen till filen som ska läsas in.
  • factory – en fabrik som används av inspelningen för att skapa en ISimulationStreamSink vid behov.

Returvärde

Den inlästa inspelningen.

Microsoft.PerceptionSimulation.PerceptionSimulationManager.LoadPerceptionSimulationRecording(System.String,Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory,Microsoft.PerceptionSimulation.ISimulationRecordingCallback)

Läs in en inspelning från den angivna filen.

Parametrar

  • path – sökvägen till filen som ska läsas in.
  • factory – en fabrik som används av inspelningen för att skapa en ISimulationStreamSink vid behov.
  • callback – ett återanrop som tar emot uppdateringar som nedgraderar inspelningens status.

Returvärde

Den inlästa inspelningen.

Microsoft.PerceptionSimulation.StreamDataTypes

Beskriver de olika typerna av dataström.

public enum StreamDataTypes
{
    None = 0x00,
    Head = 0x01,
    Hands = 0x02,
    SpatialMapping = 0x08,
    Calibration = 0x10,
    Environment = 0x20,
    SixDofControllers = 0x40,
    Eyes = 0x80,
    DisplayConfiguration = 0x100
    All = None | Head | Hands | SpatialMapping | Calibration | Environment | SixDofControllers | Eyes | DisplayConfiguration
}

Microsoft.PerceptionSimulation.StreamDataTypes.None

Ett sentinel-värde som används för att ange inga datatyper för dataströmmar.

Microsoft.PerceptionSimulation.StreamDataTypes.Head

Dataström för huvudets position och orientering.

Microsoft.PerceptionSimulation.StreamDataTypes.Hands

Dataström för händers position och gester.

Microsoft.PerceptionSimulation.StreamDataTypes.SpatialMapping

Dataström för spatial mappning av miljön.

Microsoft.PerceptionSimulation.StreamDataTypes.Kalibrering

Dataström för kalibrering av enheten. Kalibreringspaket accepteras endast av ett system i fjärrläge.

Microsoft.PerceptionSimulation.StreamDataTypes.Environment

Dataström för enhetens miljö.

Microsoft.PerceptionSimulation.StreamDataTypes.SixDofControllers

Dataström för rörelsestyrenheter.

Microsoft.PerceptionSimulation.StreamDataTypes.Eyes

Dataström med ögonen på den simulerade människan.

Microsoft.PerceptionSimulation.StreamDataTypes.DisplayConfiguration

Dataström med enhetens visningskonfiguration.

Microsoft.PerceptionSimulation.StreamDataTypes.All

Ett sentinel-värde som används för att ange alla registrerade datatyper.

Microsoft.PerceptionSimulation.ISimulationStreamSink

Ett objekt som tar emot datapaket från en simuleringsström.

public interface ISimulationStreamSink
{
    void OnPacketReceived(uint length, byte[] packet);
}

Microsoft.PerceptionSimulation.ISimulationStreamSink.OnPacketReceived(uint length, byte[] packet)

Tar emot ett enda paket, som är internt skrivet och versionshanterat.

Parametrar

  • längd – paketets längd.
  • packet – Data för paketet.

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory

Ett objekt som skapar ISimulationStreamSink.

public interface ISimulationStreamSinkFactory
{
    ISimulationStreamSink CreateSimulationStreamSink();
}

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory.CreateSimulationStreamSink()

Skapar en enda instans av ISimulationStreamSink.

Returvärde

Den skapade mottagaren.