Perception Simulation (Wahrnehmungssimulation)

Möchten Sie einen automatisierten Test für Ihre App erstellen? Möchten Sie, dass Ihre Tests über komponentenbasierte Komponententests hinausgehen und Ihre App wirklich end-to-End üben? Die Wahrnehmungssimulation ist das, wonach Sie suchen. Die Bibliothek "Wahrnehmungssimulation" sendet Eingabedaten von Menschen und Welten an Ihre App, damit Sie Ihre Tests automatisieren können. Sie können beispielsweise die Eingabe eines Menschen simulieren, der auf eine bestimmte, wiederholbare Position sucht, und dann eine Geste oder einen Bewegungscontroller verwenden.

Die Wahrnehmungssimulation kann simulierte Eingaben wie dies an eine physische HoloLens, den HoloLens-Emulator (erste Generation), den HoloLens 2-Emulator oder einen PC mit installiertem Mixed Reality-Portal senden. Die Wahrnehmungssimulation umgeht die Livesensoren auf einem Mixed Reality-Gerät und sendet simulierte Eingaben an Anwendungen, die auf dem Gerät ausgeführt werden. Anwendungen empfangen diese Eingabeereignisse über dieselben APIs, die sie immer verwenden, und können den Unterschied zwischen der Ausführung mit realen Sensoren und der Wahrnehmungssimulation nicht erkennen. Die Wahrnehmungssimulation ist die gleiche Technologie, die von den HoloLens-Emulatoren verwendet wird, um simulierte Eingaben an den virtuellen HoloLens-Computer zu senden.

Um mit der Verwendung der Simulation in Ihrem Code zu beginnen, erstellen Sie zunächst ein IPerceptionSimulationManager-Objekt. Aus diesem Objekt können Sie Befehle ausgeben, um Eigenschaften eines simulierten "Menschen" zu steuern, einschließlich Kopfposition, Handposition und Gesten. Sie können auch Bewegungscontroller aktivieren und bearbeiten.

Einrichten eines Visual Studio-Projekts für die Wahrnehmungssimulation

1. Installieren Sie den HoloLens-Emulator auf Ihrem Entwicklungs-PC. Der Emulator enthält die Bibliotheken, die Sie für die Wahrnehmungssimulation verwenden.

2. Erstellen Sie ein neues Visual Studio C#-Desktopprojekt (ein Konsolenprojekt eignet sich hervorragend für die ersten Schritte).

3. Fügen Sie dem Projekt die folgenden Binärdateien als Verweise hinzu (Project-Add-Reference>>...). Sie finden sie in %ProgramFiles(x86)%\Microsoft XDE\(Version), z. B. %ProgramFiles(x86)%\Microsoft XDE\10.0.18362.0 für den HoloLens 2-Emulator.

   Hinweis

   Obwohl die Binärdateien Teil des HoloLens 2-Emulators sind, funktionieren sie auch für Windows Mixed Reality auf dem Desktop.)

   a. PerceptionSimulationManager.Interop.dll – Verwalteter C#-Wrapper für die Wahrnehmungssimulation.
   b. PerceptionSimulationRest.dll – Bibliothek zum Einrichten eines Web-Socket-Kommunikationskanals für holoLens oder Emulator.
   c. SimulationStream.Interop.dll – Gemeinsam genutzte Typen für die Simulation.

4. Hinzufügen der binären PerceptionSimulationManager.dll der Implementierung zu Ihrem Projekt

   a. Fügen Sie es zuerst als Binärdatei zum Projekt hinzu (Project-Add-Existing>> Item...). Speichern Sie ihn als Link, damit er ihn nicht in den Projektquellordner kopiert.
   

   b. Stellen Sie dann sicher, dass sie im Build in Ihren Ausgabeordner kopiert wird. Dies befindet sich im Eigenschaftenblatt für die Binärdatei.
   

5. Legen Sie Ihre aktive Lösungsplattform auf x64 fest. (Verwenden Sie den Configuration Manager, um einen Plattformeintrag für x64 zu erstellen, wenn noch kein Eintrag vorhanden ist.)

Erstellen eines IPerceptionSimulation Manager-Objekts

Um die Simulation zu steuern, geben Sie Aktualisierungen von Objekten aus, die aus einem IPerceptionSimulationManager -Objekt abgerufen wurden. Der erste Schritt besteht darin, dieses Objekt abzurufen und mit Ihrem Zielgerät oder Emulator zu verbinden. Sie können die IP-Adresse Ihres Emulators abrufen, indem Sie auf der Symbolleiste auf die Schaltfläche "Geräteportal" klicken.

Öffnen Sie das Geräteportal: Öffnen Sie das Windows Device Portal für das HoloLens-Betriebssystem im Emulator. Für Windows Mixed Reality kann dies in der Einstellungs-App unter "Update & Sicherheit" und dann "Für Entwickler" im Abschnitt "Verbinden mit:" unter "Geräteportal aktivieren" abgerufen werden. Achten Sie darauf, sowohl die IP-Adresse als auch den Port zu beachten.

Zunächst rufen Sie RestSimulationStreamSink.Create auf, um ein RestSimulationStreamSink-Objekt abzurufen. Dies ist das Zielgerät oder der Emulator, das Sie über eine HTTP-Verbindung steuern. Ihre Befehle werden vom Windows Device Portal übergeben und verarbeitet, das auf dem Gerät oder Emulator ausgeführt wird. Die vier Parameter, die Sie zum Erstellen eines Objekts benötigen, sind:

• URI-URI - IP-Adresse des Zielgeräts (z. B. "https://123.123.123.123" oder "https://123.123.123.123:50080")
• System.Net.NetworkCredential-Anmeldeinformationen – Benutzername/Kennwort für die Verbindung mit dem Windows Device Portal auf dem Zielgerät oder Emulator. Wenn Sie über die lokale Adresse (z. B. 168..) eine Verbindung mit dem Emulator herstellen. *) auf demselben PC werden alle Anmeldeinformationen akzeptiert.
• bool normal - True für normale Priorität, false für niedrige Priorität. Sie möchten dies in der Regel auf "true " für Testszenarien festlegen, sodass Ihr Test die Kontrolle übernehmen kann. Der Emulator und die Windows Mixed Reality-Simulation verwenden Verbindungen mit niedriger Priorität. Wenn Ihr Test auch eine Verbindung mit niedriger Priorität verwendet, wird die zuletzt erstellte Verbindung kontrolliert.
• System.Threading.CancellationToken-Token – Token zum Abbrechen des asynchronen Vorgangs.

Zweitens erstellen Sie den IPerceptionSimulationManager. Dies ist das Objekt, das Sie zum Steuern der Simulation verwenden. Dies muss auch in einer asynchronen Methode erfolgen.

Steuern des simulierten Menschen

Ein IPerceptionSimulationManager verfügt über eine Human-Eigenschaft, die ein ISimulatedHuman -Objekt zurückgibt. Um den simulierten Menschen zu steuern, führen Sie Vorgänge für dieses Objekt aus. Zum Beispiel:

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

Einfache C#-Konsolenanwendung für einfaches Beispiel

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

Erweiterte C#-Konsolenanwendung

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

Hinweis auf 6-DOF-Controllern

Bevor Sie Eigenschaften für Methoden auf einem simulierten 6-DOF-Controller aufrufen, müssen Sie den Controller aktivieren. Dies führt zu einer Ausnahme. Ab dem Windows 10 Mai 2019 Update können simulierte 6-DOF-Controller installiert und aktiviert werden, indem die Status-Eigenschaft für das ISimulatedSixDofController-Objekt auf "SimulatedSixDofControllerStatus.Active" festgelegt wird. Im Windows 10 Oktober 2018 Update und früheren Versionen müssen Sie zuerst einen simulierten 6-DOF-Controller installieren, indem Sie das Tool "PerceptionSimulationDevice" im Ordner "\Windows\System32" aufrufen. Die Verwendung dieses Tools lautet wie folgt:

    PerceptionSimulationDevice.exe <action> 6dof <instance>

Beispiel:

    PerceptionSimulationDevice.exe i 6dof 1

Unterstützte Aktionen sind:

• i = installieren
• q = Abfrage
• r = entfernen

Unterstützte Instanzen sind:

• 1 = der linke 6-DOF-Controller
• 2 = der richtige 6-DOF-Controller

Der Beendigungscode des Prozesses weist auf Erfolg (null Rückgabewert) oder Fehler (ein Wert ungleich Null) hin. Wenn Sie die Aktion "q" verwenden, um abzufragen, ob ein Controller installiert ist, ist der Rückgabewert Null (0), wenn der Controller noch nicht installiert ist, oder eine (1), wenn der Controller installiert ist.

Wenn Sie einen Controller im Windows 10 Oktober 2018 Update oder einer früheren Version entfernen, legen Sie den Status zuerst über die API auf "Aus" fest, und rufen Sie dann das Tool "PerceptionSimulationDevice" auf.

Dieses Tool muss als Administrator ausgeführt werden.

API-Referenz

Microsoft.PerceptionSimulation.SimulatedDeviceType

Beschreibt einen simulierten Gerätetyp.

public enum SimulatedDeviceType
{
    Reference = 0
}

Microsoft.PerceptionSimulation.SimulatedDeviceType.Reference

Ein fiktives Referenzgerät, der Standardwert für PerceptionSimulationManager

Microsoft.PerceptionSimulation.HeadTrackerMode

Beschreibt einen Kopfverfolgungsmodus.

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

Microsoft.PerceptionSimulation.HeadTrackerMode.Default

Standardkopfverfolgung. Dies bedeutet, dass das System basierend auf Laufzeitbedingungen den besten Head Tracking-Modus auswählen kann.

Microsoft.PerceptionSimulation.HeadTrackerMode.Orientation

Ausrichtung nur Nachverfolgung des Kopfs. Dies bedeutet, dass die nachverfolgte Position möglicherweise nicht zuverlässig ist, und einige Funktionen, die von der Kopfposition abhängig sind, sind möglicherweise nicht verfügbar.

Microsoft.PerceptionSimulation.HeadTrackerMode.Position

Positionskopfverfolgung. Dies bedeutet, dass die nachverfolgte Kopfposition und Ausrichtung beide zuverlässig sind.

Microsoft.PerceptionSimulation.SimulatedGesture

Beschreibt eine simulierte Geste

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

Microsoft.PerceptionSimulation.SimulatedGesture.None

Ein Sentinelwert, der verwendet wird, um keine Gesten anzugeben.

Microsoft.PerceptionSimulation.SimulatedGesture.FingerPressed

Ein Finger drückte die Geste.

Microsoft.PerceptionSimulation.SimulatedGesture.FingerReleased

Ein Finger hat eine Geste losgelassen.

Microsoft.PerceptionSimulation.SimulatedGesture.Home

Die Start-/Systemgeste.

Microsoft.PerceptionSimulation.SimulatedGesture.Max

Die maximale gültige Geste.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus

Die möglichen Zustände eines simulierten 6-DOF-Controllers.

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

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Off

Der 6-DOF-Controller ist ausgeschaltet.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Active

Der 6-DOF-Controller ist eingeschaltet und nachverfolgt.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.TrackingLost

Der 6-DOF-Controller ist aktiviert, kann aber nicht nachverfolgt werden.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton

Die unterstützten Schaltflächen auf einem simulierten 6-DOF-Controller.

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

Ein Sentinelwert, der verwendet wird, um keine Schaltflächen anzugeben.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Home

Die Schaltfläche "Start" wird gedrückt.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Menu

Die Menüschaltfläche wird gedrückt.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Grip

Die Grifftaste wird gedrückt.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.TouchpadPress

Das TouchPad wird gedrückt.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Select

Die Schaltfläche "Auswählen" wird gedrückt.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.TouchpadTouch

Das TouchPad wird berührt.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Thumbstick

Der Ministick wird gedrückt.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Max

Die maximal gültige Schaltfläche.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState

Der Kalibrierungszustand der simulierten Augen

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

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Unavailable

Die Augenkalibrierung ist nicht verfügbar.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Ready

Die Augen wurden kalibriert. Dies ist der Standardwert.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Configuring

Die Augen werden kalibriert.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.UserCalibrationNeeded

Die Augen müssen kalibriert werden.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy

Die Tracking-Genauigkeit eines Handgelenks.

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

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Unavailable

Das Gelenk wird nicht nachverfolgt.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Approximate

Die gemeinsame Position wird abgeleitet.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Visible

Das Gelenk wird vollständig nachverfolgt.

Microsoft.PerceptionSimulation.SimulatedHandPose

Die Tracking-Genauigkeit eines Handgelenks.

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

Microsoft.PerceptionSimulation.SimulatedHandPose.Closed

Die Fingergelenke der Hand sind so konfiguriert, dass sie eine geschlossene Pose widerspiegeln.

Microsoft.PerceptionSimulation.SimulatedHandPose.Open

Die Fingergelenke der Hand sind so konfiguriert, dass sie eine offene Pose widerspiegeln.

Microsoft.PerceptionSimulation.SimulatedHandPose.Point

Die Fingergelenke der Hand sind so konfiguriert, dass sie eine zeigende Pose widerspiegeln.

Microsoft.PerceptionSimulation.SimulatedHandPose.Pinch

Die Fingergelenke der Hand sind so konfiguriert, dass sie eine zusammendrückende Pose widerspiegeln.

Microsoft.PerceptionSimulation.SimulatedHandPose.Max

Der maximal gültige Wert für SimulatedHandPose.

Microsoft.PerceptionSimulation.PlaybackState

Beschreibt den Zustand einer Wiedergabe.

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

Microsoft.PerceptionSimulation.PlaybackState.Stopped

Die Aufzeichnung wird zurzeit beendet und kann zur Wiedergabe bereit sein.

Microsoft.PerceptionSimulation.PlaybackState.Playing

Die Aufzeichnung wird derzeit wiedergegeben.

Microsoft.PerceptionSimulation.PlaybackState.Paused

Die Aufzeichnung wird zurzeit angehalten.

Microsoft.PerceptionSimulation.PlaybackState.End

Die Aufzeichnung wurde am Ende erreicht.

Microsoft.PerceptionSimulation.Vector3

Beschreibt einen drei Komponentenvektor, der einen Punkt oder einen Vektor im 3D-Raum beschreiben kann.

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

Microsoft.PerceptionSimulation.Vector3.X

Die X-Komponente des Vektors.

Microsoft.PerceptionSimulation.Vector3.Y

Die Y-Komponente des Vektors.

Microsoft.PerceptionSimulation.Vector3.Z

Die Z-Komponente des Vektors.

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

Erstellen Sie einen neuen Vector3.

Parameter

• x - Die x-Komponente des Vektors.
• y - Die y-Komponente des Vektors.
• z - Die z-Komponente des Vektors.

Microsoft.PerceptionSimulation.Rotation3

Beschreibt eine Dreikomponentendrehung.

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

Microsoft.PerceptionSimulation.Rotation3.Pitch

Die Pitch-Komponente der Drehung um die X-Achse nach unten.

Microsoft.PerceptionSimulation.Rotation3.Yaw

Die Gierkomponente der Drehung, direkt um die Y-Achse.

Microsoft.PerceptionSimulation.Rotation3.Roll

Die Rolle-Komponente der Drehung, direkt um die Z-Achse.

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

Erstellen Sie eine neue Drehung3.

Parameter

• Pitch - Die Neigungskomponente der Drehung.
• Schwenken – Die Gierkomponente der Drehung.
• roll - Die Rollkomponente der Drehung.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration

Beschreibt die Konfiguration eines Gelenks auf einer simulierten Hand.

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

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.Position

Die Position des Gelenks.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.Rotation

Die Drehung des Gelenks.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.TrackingAccuracy

Die Nachverfolgungsgenauigkeit des Gelenks.

Microsoft.PerceptionSimulation.Frustum

Beschreibt ein Ansichts-Frustum, wie in der Regel von einer Kamera verwendet.

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

Microsoft.PerceptionSimulation.Frustum.Near

Der Mindestabstand, der im Frustum enthalten ist.

Microsoft.PerceptionSimulation.Frustum.Far

Der maximale Abstand, der im Frustum enthalten ist.

Microsoft.PerceptionSimulation.Frustum.FieldOfView

Das horizontale Sichtfeld des Frustums in Bogenmaß (kleiner als PI).

Microsoft.PerceptionSimulation.Frustum.AspectRatio

Das Verhältnis des horizontalen Ansichtsfelds zu einem vertikalen Ansichtsfeld.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration

Beschreibt die Konfiguration der Anzeige des simulierten Headsets.

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

Die Transformation von der Mitte des Kopfes in das linke Auge zum Zwecke des Stereorenderings.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.LeftEyeRotation

Die Drehung des linken Auges zum Zwecke des Stereorenderings.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyePosition

Die Transformation von der Mitte des Kopfes zum rechten Auge für die Zwecke des Stereorenderings.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyeRotation

Die Drehung des rechten Auges zum Zwecke des Stereorenderings.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.Ipd

Der vom System gemeldete Ipd-Wert für die Zwecke des Stereorenderings.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyEyeTransforms

Gibt an, ob die für links- und rechte Augentransformationen vorgesehenen Werte als gültig betrachtet und auf das laufende System angewendet werden sollen.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyIpd

Gibt an, ob der für Ipd bereitgestellte Wert als gültig betrachtet und auf das ausgeführte System angewendet werden soll.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager

Stamm zum Generieren der Pakete, die zum Steuern eines Geräts verwendet werden.

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

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Device

Rufen Sie das simulierte Geräteobjekt ab, das den simulierten Menschen und die simulierte Welt interpretiert.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Human

Rufen Sie das Objekt ab, das den simulierten Menschen steuert.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Reset

Setzt die Simulation auf den Standardzustand zurück.

Microsoft.PerceptionSimulation.ISimulatedDevice

Schnittstelle, die das Gerät beschreibt, das die simulierte Welt und den simulierten Menschen interpretiert

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

Microsoft.PerceptionSimulation.ISimulatedDevice.HeadTracker

Rufen Sie den Head Tracker vom simulierten Gerät ab.

Microsoft.PerceptionSimulation.ISimulatedDevice.HandTracker

Rufen Sie den Handtracker vom simulierten Gerät ab.

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

Legen Sie die Eigenschaften des simulierten Geräts so fest, dass sie dem bereitgestellten Gerätetyp entsprechen.

Parameter

• type – Der neue Typ des simulierten Geräts

Microsoft.PerceptionSimulation.ISimulatedDevice2

Zusätzliche Eigenschaften sind verfügbar, indem ISimulatedDevice in ISimulatedDevice2 umgestellt wird.

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

};

Microsoft.PerceptionSimulation.ISimulatedDevice2.IsUserPresent

Rufen Sie ab oder legen Sie fest, ob der simulierte Mensch das Headset aktiv trägt.

Microsoft.PerceptionSimulation.ISimulatedDevice2.DisplayConfiguration

Dient zum Abrufen oder Festlegen der Eigenschaften der simulierten Anzeige.

Microsoft.PerceptionSimulation.ISimulatedHeadTracker

Schnittstelle, die den Teil des simulierten Geräts beschreibt, der den Kopf des simulierten Menschen verfolgt.

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

Microsoft.PerceptionSimulation.ISimulatedHeadTracker.HeadTrackerMode

Ruft den aktuellen Head Tracker-Modus ab und legt den Modus fest.

Microsoft.PerceptionSimulation.ISimulatedHandTracker

Schnittstelle, die den Teil des simulierten Geräts beschreibt, der die Hände des simulierten Menschen verfolgt

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

Rufen Sie die Position des Knotens mit Bezug zur Welt in Metern ab.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Position

Rufen Sie die Position des simulierten Handtrackers relativ zur Mitte des Kopfes ab, und legen Sie sie fest.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Pitch

Rufen Sie den Abwärtswinkel des simulierten Handtrackers ab, und legen Sie sie fest.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.FrustumIgnored

Rufen Sie ab, und legen Sie fest, ob das Frustum des simulierten Hand-Trackers ignoriert wird. Wenn sie ignoriert werden, sind beide Hände immer sichtbar. Wenn nicht ignorierte (standard) Hände nur sichtbar sind, wenn sie sich innerhalb des Frustums des Hand-Trackers befinden.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Frustum

Dient zum Abrufen und Festlegen der frustum-Eigenschaften, die verwendet werden, um festzustellen, ob die Hände für den simulierten Hand-Tracker sichtbar sind.

Microsoft.PerceptionSimulation.ISimulatedHuman

Schnittstelle der obersten Ebene zum Steuern des simulierten Menschen.

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

Dient zum Abrufen und Festlegen der Position des Knotens in Bezug auf die Welt in Metern. Die Position entspricht einem Punkt am Mittelpunkt der Füße des Menschen.

Microsoft.PerceptionSimulation.ISimulatedHuman.Direction

Rufen Sie die Richtung der simulierten menschlichen Gesichter in der Welt ab, und legen Sie sie fest. 0 Bogenmaße stehen auf der negativen Z-Achse. Positive Bogenmaße drehen sich im Uhrzeigersinn um die Y-Achse.

Microsoft.PerceptionSimulation.ISimulatedHuman.Height

Rufen Sie die Höhe des simulierten Menschen in Metern ab, und legen Sie sie fest.

Microsoft.PerceptionSimulation.ISimulatedHuman.LeftHand

Rufen Sie die linke Hand des simulierten Menschen ab.

Microsoft.PerceptionSimulation.ISimulatedHuman.RightHand

Rufen Sie die rechte Hand des simulierten Menschen ab.

Microsoft.PerceptionSimulation.ISimulatedHuman.Head

Rufen Sie den Kopf des simulierten Menschen ab.

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

Bewegen Sie den simulierten Menschen relativ zu seiner aktuellen Position in Metern.

Parameter

• übersetzung – Die zu verschiebende Übersetzung relativ zur aktuellen Position.

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

Drehen des simulierten Menschen relativ zur aktuellen Richtung, im Uhrzeigersinn über die Y-Achse

Parameter

• Bogenmaß - Der Betrag, der um die Y-Achse gedreht werden soll.

Microsoft.PerceptionSimulation.ISimulatedHuman2

Zusätzliche Eigenschaften sind verfügbar, indem das ISimulatedHuman in ISimulatedHuman2 umzuwandlungen wird.

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

Microsoft.PerceptionSimulation.ISimulatedHuman2.LeftController

Rufen Sie den linken 6-DOF-Controller ab.

Microsoft.PerceptionSimulation.ISimulatedHuman2.RightController

Rufen Sie den richtigen 6-DOF-Controller ab.

Microsoft.PerceptionSimulation.ISimulatedHand

Schnittstelle, die eine Hand des simulierten Menschen beschreibt

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

Rufen Sie die Position des Knotens mit Bezug zur Welt in Metern ab.

Microsoft.PerceptionSimulation.ISimulatedHand.Position

Rufen Sie die Position der simulierten Hand relativ zum Menschen in Metern ab, und legen Sie sie fest.

Microsoft.PerceptionSimulation.ISimulatedHand.Activated

Rufen Sie ab, und legen Sie fest, ob die Hand zurzeit aktiviert ist.

Microsoft.PerceptionSimulation.ISimulatedHand.Visible

Rufen Sie ab, ob die Hand zurzeit für das SimulatedDevice sichtbar ist (d. a. ob sie an einer Position ist, die vom HandTracker erkannt werden soll).

Microsoft.PerceptionSimulation.ISimulatedHand.EnsureVisible

Bewegen Sie die Hand so, dass sie für das SimulatedDevice sichtbar ist.

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

Verschieben Sie die Position der simulierten Hand relativ zur aktuellen Position in Metern.

Parameter

• übersetzung – Der Betrag, um den simulierten Hand zu übersetzen.

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

Führen Sie eine Geste mithilfe der simulierten Hand aus. Sie wird nur vom System erkannt, wenn die Hand aktiviert ist.

Parameter

• Geste – Die auszuführende Geste.

Microsoft.PerceptionSimulation.ISimulatedHand2

Zusätzliche Eigenschaften sind verfügbar, indem sie ein ISimulatedHand in ISimulatedHand2 umwandeln.

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

Microsoft.PerceptionSimulation.ISimulatedHand2.Orientation

Abrufen oder Festlegen der Drehung der simulierten Hand. Positive Bogenmaße drehen sich im Uhrzeigersinn, wenn Sie entlang der Achse sehen.

Microsoft.PerceptionSimulation.ISimulatedHand3

Zusätzliche Eigenschaften sind durch Umwandeln eines ISimulatedHand in ISimulatedHand3 verfügbar.

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

Rufen Sie die gemeinsame Konfiguration für das angegebene Gelenk ab.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetJointConfiguration

Legen Sie die gemeinsame Konfiguration für die angegebene Verbindung fest.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetHandPose

Legen Sie die Hand auf eine bekannte Pose mit einer optionalen Kennzeichnung fest, die animiert werden soll. Hinweis: Das Animieren führt nicht dazu, dass Gelenke sofort ihre endgültigen Gelenkkonfigurationen widerspiegeln.

Microsoft.PerceptionSimulation.ISimulatedHead

Schnittstelle, die den Kopf des simulierten Menschen beschreibt.

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

Microsoft.PerceptionSimulation.ISimulatedHead.WorldPosition

Rufen Sie die Position des Knotens mit Bezug zur Welt in Metern ab.

Microsoft.PerceptionSimulation.ISimulatedHead.Rotation

Rufen Sie die Drehung des simulierten Kopfs ab. Positive Bogenmaße drehen sich im Uhrzeigersinn, wenn Sie entlang der Achse sehen.

Microsoft.PerceptionSimulation.ISimulatedHead.Diameter

Rufen Sie den Durchmesser des simulierten Kopfs ab. Dieser Wert wird verwendet, um den Mittelpunkt des Kopfes (Drehpunkt) zu bestimmen.

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

Drehen Sie den simulierten Kopf relativ zur aktuellen Drehung. Positive Bogenmaße drehen sich im Uhrzeigersinn, wenn Sie entlang der Achse sehen.

Parameter

• Drehung – Der zu drehende Betrag.

Microsoft.PerceptionSimulation.ISimulatedHead2

Zusätzliche Eigenschaften sind verfügbar, indem sie einen ISimulatedHead in ISimulatedHead2 umwandeln.

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

Microsoft.PerceptionSimulation.ISimulatedHead2.Eyes

Rufen Sie die Augen des simulierten Menschen ab.

Microsoft.PerceptionSimulation.ISimulatedSixDofController

Schnittstelle, die einen 6-DOF-Controller beschreibt, der dem simulierten Menschen zugeordnet ist.

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

Rufen Sie die Position des Knotens mit Bezug zur Welt in Metern ab.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Status

Dient zum Abrufen oder Festlegen des aktuellen Zustands des Controllers. Der Controllerstatus muss auf einen anderen Wert als "Aus" festgelegt werden, bevor alle Anrufe zum Verschieben, Drehen oder Drücken von Tasten erfolgreich ausgeführt werden.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Position

Dient zum Abrufen oder Festlegen der Position des simulierten Controllers relativ zum Menschen in Metern.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Orientation

Abrufen oder Festlegen der Ausrichtung des simulierten Controllers.

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

Verschieben Sie die Position des simulierten Controllers relativ zur aktuellen Position in Metern.

Parameter

• übersetzung – Der Betrag, um den simulierten Controller zu übersetzen.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.PressButton(SimulatedSixDofControllerButton)

Drücken Sie eine Taste auf dem simulierten Controller. Sie wird nur vom System erkannt, wenn der Controller aktiviert ist.

Parameter

• button - Die Taste, die gedrückt werden soll.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.ReleaseButton(SimulatedSixDofControllerButton)

Lassen Sie eine Taste auf dem simulierten Controller los. Sie wird nur vom System erkannt, wenn der Controller aktiviert ist.

Parameter

• button - Die Schaltfläche, die losgelassen werden soll.

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

Rufen Sie die Position eines simulierten Fingers auf dem Touchpad des simulierten Controllers ab.

Parameter

• x – Die horizontale Position des Fingers.
• y – Die vertikale Position des Fingers.

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

Legen Sie die Position eines simulierten Fingers auf dem Touchpad des simulierten Controllers fest.

Parameter

• x – Die horizontale Position des Fingers.
• y – Die vertikale Position des Fingers.

Microsoft.PerceptionSimulation.ISimulatedSixDofController2

Zusätzliche Eigenschaften und Methoden stehen zur Verfügung, indem sie einen ISimulatedSixDofController in ISimulatedSixDofController2 umwandeln.

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)

Rufen Sie die Position des simulierten Ministicks auf dem simulierten Controller ab.

Parameter

• x - Die horizontale Position des Ministicks.
• y - Die vertikale Position des Ministicks.

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

Legen Sie die Position des simulierten Ministicks auf dem simulierten Controller fest.

Parameter

• x - Die horizontale Position des Ministicks.
• y - Die vertikale Position des Ministicks.

Microsoft.PerceptionSimulation.ISimulatedSixDofController2.BatteryLevel

Abrufen oder Festlegen des Akkustands des simulierten Controllers. Der Wert muss größer als 0,0 und kleiner als oder gleich 100,0 sein.

Microsoft.PerceptionSimulation.ISimulatedEyes

Schnittstelle, die die Augen des simulierten Menschen beschreibt.

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

Microsoft.PerceptionSimulation.ISimulatedEyes.Rotation

Rufen Sie die Drehung der simulierten Augen ab. Positive Bogenmaße drehen sich im Uhrzeigersinn, wenn Sie entlang der Achse sehen.

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

Drehen Sie die simulierten Augen relativ zur aktuellen Drehung. Positive Bogenmaße drehen sich im Uhrzeigersinn, wenn Sie entlang der Achse sehen.

Parameter

• Drehung – Der zu drehende Betrag.

Microsoft.PerceptionSimulation.ISimulatedEyes.CalibrationState

Ruft den Kalibrierungszustand der simulierten Augen ab oder legt den Kalibrierungszustand fest.

Microsoft.PerceptionSimulation.ISimulatedEyes.WorldPosition

Rufen Sie die Position des Knotens mit Bezug zur Welt in Metern ab.

Microsoft.PerceptionSimulation.ISimulationRecording

Schnittstelle für die Interaktion mit einer einzelnen Aufzeichnung, die für die Wiedergabe geladen wurde.

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

Microsoft.PerceptionSimulation.ISimulationRecording.DataTypes

Ruft die Liste der Datentypen in der Aufzeichnung ab.

Microsoft.PerceptionSimulation.ISimulationRecording.State

Ruft den aktuellen Zustand der Aufzeichnung ab.

Microsoft.PerceptionSimulation.ISimulationRecording.Play

Starten Sie die Wiedergabe. Wenn die Aufzeichnung angehalten wird, wird die Wiedergabe vom angehaltenen Speicherort fortgesetzt. wenn die Wiedergabe beendet wird, beginnt die Wiedergabe am Anfang. Wenn dieser Aufruf bereits wiedergegeben wird, wird dieser Aufruf ignoriert.

Microsoft.PerceptionSimulation.ISimulationRecording.Pause

Hält die Wiedergabe an der aktuellen Position an. Wenn die Aufzeichnung beendet wird, wird der Anruf ignoriert.

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

Sucht die Aufzeichnung an der angegebenen Zeit (in 100-Nanosekunden-Intervallen vom Anfang) und hält an dieser Position an. Wenn die Zeit über das Ende der Aufzeichnung hinausgeht, wird sie am letzten Frame angehalten.

Parameter

• ticks - Die Zeit, zu der gesucht werden soll.

Microsoft.PerceptionSimulation.ISimulationRecording.Stop

Beendet die Wiedergabe und setzt die Position auf den Anfang zurück.

Microsoft.PerceptionSimulation.ISimulationRecordingCallback

Schnittstelle zum Empfangen von Zustandsänderungen während der Wiedergabe.

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

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

Wird aufgerufen, wenn sich der Wiedergabestatus eines ISimulationRecording geändert hat.

Parameter

• newState – Der neue Zustand der Aufzeichnung.

Microsoft.PerceptionSimulation.PerceptionSimulationManager

Stammobjekt zum Erstellen von Wahrnehmungssimulationsobjekten.

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)

Erstellen Sie ein Objekt zum Generieren simulierter Pakete und liefern Sie sie an die bereitgestellte Spüle.

Parameter

• sink - Die Spüle, die alle generierten Pakete empfängt.

Rückgabewert

Der erstellte Manager.

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

Erstellen Sie eine Spüle, die alle empfangenen Pakete in einer Datei im angegebenen Pfad speichert.

Parameter

• path - Der Pfad der zu erstellenden Datei.

Rückgabewert

Die erstellte Spüle.

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

Laden sie eine Aufzeichnung aus der angegebenen Datei.

Parameter

• path - Der Pfad der zu ladenden Datei.
• factory - Eine Fabrik, die von der Aufzeichnung zum Erstellen eines ISimulationStreamSink verwendet wird, wenn erforderlich.

Rückgabewert

Die geladene Aufzeichnung.

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

Laden sie eine Aufzeichnung aus der angegebenen Datei.

Parameter

• path - Der Pfad der zu ladenden Datei.
• factory - Eine Fabrik, die von der Aufzeichnung zum Erstellen eines ISimulationStreamSink verwendet wird, wenn erforderlich.
• callback – Ein Rückruf, der Aktualisierungen empfängt, die den Status der Aufzeichnung aktualisieren.

Rückgabewert

Die geladene Aufzeichnung.

Microsoft.PerceptionSimulation.StreamDataTypes

Beschreibt die verschiedenen Arten von Datenstromdaten.

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

Ein Sentinelwert, der verwendet wird, um keine Datenstromdatentypen anzugeben.

Microsoft.PerceptionSimulation.StreamDataTypes.Head

Datenstrom für die Position und Ausrichtung des Kopfes.

Microsoft.PerceptionSimulation.StreamDataTypes.Hands

Datenstrom für die Position und Gesten der Hände.

Microsoft.PerceptionSimulation.StreamDataTypes.SpatialMapping

Datenstrom zur räumlichen Zuordnung der Umgebung.

Microsoft.PerceptionSimulation.StreamDataTypes.Calibration

Datenstrom für die Kalibrierung des Geräts. Kalibrierungspakete werden nur von einem System im Remotemodus akzeptiert.

Microsoft.PerceptionSimulation.StreamDataTypes.Environment

Datenstrom für die Umgebung des Geräts.

Microsoft.PerceptionSimulation.StreamDataTypes.SixDofControllers

Datenstrom für Bewegungscontroller.

Microsoft.PerceptionSimulation.StreamDataTypes.Eyes

Datenstrom mit den Augen des simulierten Menschen.

Microsoft.PerceptionSimulation.StreamDataTypes.DisplayConfiguration

Datenstrom mit der Anzeigekonfiguration des Geräts.

Microsoft.PerceptionSimulation.StreamDataTypes.All

Ein Sentinelwert, der verwendet wird, um alle aufgezeichneten Datentypen anzugeben.

Microsoft.PerceptionSimulation.ISimulationStreamSink

Ein Objekt, das Datenpakete aus einem Simulationsdatenstrom empfängt.

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

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

Empfängt ein einzelnes Paket, das intern typiert und versionsgeformt ist.

Parameter

• length - Die Länge des Pakets.
• packet - Die Daten des Pakets.

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory

Ein Objekt, das ISimulationStreamSink erstellt.

public interface ISimulationStreamSinkFactory
{
    ISimulationStreamSink CreateSimulationStreamSink();
}

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory.CreateSimulationStreamSink()

Erstellt eine einzelne Instanz von ISimulationStreamSink.

Rückgabewert

Die erstellte Spüle.