Symulacja percepcji

Artykuł
03/21/2023

Czy chcesz utworzyć zautomatyzowany test dla aplikacji? Czy chcesz, aby testy wykraczały poza testowanie jednostkowe na poziomie składnika i naprawdę ćwiczyć kompleksową aplikację? Symulacja percepcji jest tym, czego szukasz. Biblioteka symulacji percepcji wysyła dane wejściowe człowieka i świata do aplikacji, aby można było zautomatyzować testy. Na przykład można symulować dane wejściowe człowieka, który szuka konkretnego, powtarzalnego położenia, a następnie użyć gestu lub kontrolera ruchu.

Symulacja percepcji może wysyłać symulowane dane wejściowe, takie jak to do fizycznego urządzenia HoloLens, emulatora urządzenia HoloLens (pierwszej generacji), emulatora HoloLens 2 lub komputera z zainstalowanym portalem Mixed Reality. Symulacja percepcji pomija czujniki na żywo na urządzeniu Mixed Reality i wysyła symulowane dane wejściowe do aplikacji działających na urządzeniu. Aplikacje odbierają te zdarzenia wejściowe za pośrednictwem tych samych interfejsów API, których zawsze używają i nie mogą powiedzieć różnicy między uruchamianiem z rzeczywistymi czujnikami a symulacją percepcji. Symulacja percepcji jest tą samą technologią używaną przez emulatory HoloLens do wysyłania symulowanych danych wejściowych do maszyny wirtualnej HoloLens.

Aby rozpocząć korzystanie z symulacji w kodzie, zacznij od utworzenia obiektu IPerceptionSimulationManager. Z tego obiektu można wydać polecenia, aby kontrolować właściwości symulowanego "człowieka", w tym położenie głowy, położenie dłoni i gesty. Można również włączać kontrolery ruchu i manipulować nimi.

Konfigurowanie projektu programu Visual Studio na potrzeby symulacji percepcji

Zainstaluj emulator urządzenia HoloLens na komputerze dewelopera. Emulator zawiera biblioteki używane do symulacji percepcji.
Tworzenie nowego projektu klasycznego programu Visual Studio C# (projekt konsoli działa świetnie, aby rozpocząć pracę).
Dodaj następujące pliki binarne do projektu jako odwołania (Project-Add-Reference>>...). Można je znaleźć w folderze %ProgramFiles(x86)%\Microsoft XDE\(version), takim jak %ProgramFiles(x86)%\Microsoft XDE\10.0.18362.0 dla emulatora HoloLens 2.

Uwaga

Chociaż pliki binarne są częścią emulatora HoloLens 2, działają również dla Windows Mixed Reality na pulpicie).

a. PerceptionSimulationManager.Interop.dll — zarządzana otoka języka C# na potrzeby symulacji percepcji.
b. PerceptionSimulationRest.dll — biblioteka do konfigurowania kanału komunikacyjnego gniazda internetowego do urządzenia HoloLens lub emulatora.
c. SimulationStream.Interop.dll — typy udostępnione do symulacji.
Dodawanie PerceptionSimulationManager.dll binarnej implementacji do projektu

a. Najpierw dodaj go jako plik binarny do projektu (Project-Add-Existing>> Item...). Zapisz go jako link, aby nie skopiował go do folderu źródłowego projektu.

b. Następnie upewnij się, że zostanie skopiowany do folderu wyjściowego w kompilacji. Znajduje się to w arkuszu właściwości dla pliku binarnego.
Ustaw aktywną platformę rozwiązania na x64. (Użyj Configuration Manager, aby utworzyć wpis platformy dla x64, jeśli jeszcze nie istnieje).

Tworzenie obiektu menedżera IPerceptionSimulation

Aby kontrolować symulację, należy wydać aktualizacje obiektów pobranych z obiektu IPerceptionSimulationManager. Pierwszym krokiem jest pobranie tego obiektu i połączenie go z urządzeniem docelowym lub emulatorem. Adres IP emulatora można uzyskać, klikając przycisk Portal urządzeń na pasku narzędzi

Otwórz ikonę Portal urządzeń Otwórz portal urządzeń: otwórz portal urządzeń z systemem Windows dla systemu operacyjnego HoloLens w emulatorze. W przypadku Windows Mixed Reality można to pobrać w aplikacji Ustawienia w obszarze "Aktualizuj zabezpieczenia &", a następnie "Dla deweloperów" w sekcji "Połącz przy użyciu:" w obszarze "Włącz portal urządzeń". Pamiętaj, aby zanotować zarówno adres IP, jak i port.

Najpierw wywołasz metodę RestSimulationStreamSink.Create, aby uzyskać obiekt RestSimulationStreamSink. Jest to docelowe urządzenie lub emulator, którym będziesz kontrolować połączenie http. Polecenia zostaną przekazane do portalu urządzeń z systemem Windows uruchomionego na urządzeniu lub emulatorze i obsłużone przez niego. Cztery parametry, które należy utworzyć, to:

Identyfikator URI — adres IP urządzenia docelowego (np. "https://123.123.123.123" lub "https://123.123.123.123:50080")
Poświadczenia System.Net.NetworkCredential — nazwa użytkownika/hasło służące do nawiązywania połączenia z portalem urządzeń z systemem Windows na urządzeniu docelowym lub emulatorze. Jeśli łączysz się z emulatorem za pośrednictwem adresu lokalnego (np. 168... *) na tym samym komputerze wszystkie poświadczenia zostaną zaakceptowane.
wartość logiczna normalna — prawda dla normalnego priorytetu, fałsz dla niskiego priorytetu. Zazwyczaj chcesz ustawić tę wartość na wartość true dla scenariuszy testowych, co pozwala na przejęcie kontroli nad testem. Emulator i symulacja Windows Mixed Reality używają połączeń o niskim priorytcie. Jeśli test używa również połączenia o niskim priorytetzie, ostatnio nawiązane połączenie będzie w kontrolce.
Token System.Threading.CancelToken — token umożliwiający anulowanie operacji asynchronicznych.

Po drugie utworzysz element IPerceptionSimulationManager. Jest to obiekt używany do kontrolowania symulacji. Należy to również zrobić w metodzie asynchronicznej.

Kontrolowanie symulowanego człowieka

Obiekt IPerceptionSimulationManager ma właściwość Human, która zwraca obiekt ISimulatedHuman. Aby kontrolować symulowanego człowieka, wykonaj operacje na tym obiekcie. Na przykład:

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

Podstawowa przykładowa aplikacja konsolowa języka C#

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

Rozszerzona przykładowa aplikacja konsolowa języka C#

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

Uwaga dotycząca kontrolerów 6-DOF

Przed wywołaniem wszelkich właściwości metod na symulowanym kontrolerze 6-DOF należy aktywować kontroler. Nie spowoduje to wyjątku. Począwszy od Aktualizacja systemu Windows 10 z maja 2019, symulowane kontrolery 6-DOF można zainstalować i aktywować, ustawiając właściwość Status w obiekcie ISimulatedSixDofController na SimulatedSixDofControllerStatus.Active. W Aktualizacja systemu Windows 10 z października 2018 i starszych należy najpierw zainstalować symulowany kontroler 6-DOF, wywołując narzędzie PerceptionSimulationDevice znajdujące się w folderze \Windows\System32. Użycie tego narzędzia jest następujące:

    PerceptionSimulationDevice.exe <action> 6dof <instance>

Na przykład

    PerceptionSimulationDevice.exe i 6dof 1

Obsługiwane akcje to:

i = install
q = zapytanie
r = usuń

Obsługiwane wystąpienia to:

1 = lewy kontroler 6-DOF
2 = odpowiedni kontroler 6-DOF

Kod zakończenia procesu wskaże powodzenie (wartość zwracana zero) lub niepowodzenie (wartość zwracana bez zera). Jeśli używasz akcji "q", aby zapytać, czy kontroler jest zainstalowany, wartość zwracana będzie zero (0), jeśli kontroler nie jest jeszcze zainstalowany lub jeden (1), jeśli kontroler jest zainstalowany.

Podczas usuwania kontrolera na Aktualizacja systemu Windows 10 z października 2018 lub starszej ustaw jego stan na Wyłączone za pośrednictwem interfejsu API, a następnie wywołaj narzędzie PerceptionSimulationDevice.

To narzędzie musi być uruchamiane jako administrator.

Dokumentacja interfejsu API

Microsoft.PerceptionSimulation.SimulatedDeviceType

Opisuje typ symulowanego urządzenia

public enum SimulatedDeviceType
{
    Reference = 0
}

Microsoft.PerceptionSimulation.SimulatedDeviceType.Reference

Fikcyjne urządzenie referencyjne, domyślne dla elementu PerceptionSimulationManager

Microsoft.PerceptionSimulation.HeadTrackerMode

Opisuje tryb monitora głowy

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

Microsoft.PerceptionSimulation.HeadTrackerMode.Default

Domyślne śledzenie głowy. Oznacza to, że system może wybrać najlepszy tryb śledzenia głowy na podstawie warunków środowiska uruchomieniowego.

Microsoft.PerceptionSimulation.HeadTrackerMode.Orientation

Orientacja tylko śledzenie głowy. Oznacza to, że pozycja śledzona może nie być niezawodna, a niektóre funkcje zależne od położenia głowy mogą nie być dostępne.

Microsoft.PerceptionSimulation.HeadTrackerMode.Position

Śledzenie głowicy pozycyjnej. Oznacza to, że śledzone położenie głowy i orientacja są niezawodne

Microsoft.PerceptionSimulation.SimulatedGesture

Opisuje symulowany gest

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

Microsoft.PerceptionSimulation.SimulatedGesture.None

Wartość sentinel używana do wskazywania żadnych gestów.

Microsoft.PerceptionSimulation.SimulatedGesture.FingerPressed

Gest naciśnięty palcem.

Microsoft.PerceptionSimulation.SimulatedGesture.FingerReleased

Palec zwolniony gest.

Microsoft.PerceptionSimulation.SimulatedGesture.Home

Gest domu/systemu.

Microsoft.PerceptionSimulation.SimulatedGesture.Max

Maksymalny prawidłowy gest.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus

Możliwe stany symulowanego kontrolera 6-DOF.

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

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Off

Kontroler 6-DOF jest wyłączony.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Active

Kontroler 6-DOF jest włączony i śledzony.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.TrackingLost

Kontroler 6-DOF jest włączony, ale nie można go śledzić.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton

Obsługiwane przyciski na symulowanym kontrolerze 6-DOF.

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

Wartość sentinel używana do wskazywania brak przycisków.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Home

Przycisk Strona główna jest naciśnięty.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Menu

Przycisk Menu jest naciśnięty.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Grip

Przycisk Uchwyt jest naciśnięty.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.TouchpadPress

Klawiatura TouchPad jest naciśnięta.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Select

Przycisk Wybierz jest naciśnięty.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.TouchpadTouch

TouchPad jest dotykany.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Thumbstick

Naciśnięty jest kciuk.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Max

Maksymalny prawidłowy przycisk.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState

Stan kalibracji symulowanych oczu

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

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Unavailable

Kalibracja oczu jest niedostępna.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Ready

Oczy zostały skalibrowane. Jest to wartość domyślna.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Configuring

Oczy są skalibrowane.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.UserCalibrationNeeded

Oczy muszą być skalibrowane.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy

Dokładność śledzenia ręki.

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

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Unavailable

Staw nie jest śledzony.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Approximate

Wspólne stanowisko jest wnioskowane.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Visible

Staw jest w pełni śledzony.

Microsoft.PerceptionSimulation.SimulatedHandPose

Dokładność śledzenia ręki.

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

Microsoft.PerceptionSimulation.SimulatedHandPose.Closed

Stawy palców ręki są skonfigurowane do odzwierciedlenia zamkniętej pozy.

Microsoft.PerceptionSimulation.SimulatedHandPose.Open

Stawy palców ręki są skonfigurowane do odzwierciedlenia otwartej pozy.

Microsoft.PerceptionSimulation.SimulatedHandPose.Point

Stawy palców ręki są skonfigurowane do odzwierciedlenia punktowej pozy.

Microsoft.PerceptionSimulation.SimulatedHandPose.Pinch

Stawy palców ręki są skonfigurowane do odzwierciedlenia uszczypnięcia pozy.

Microsoft.PerceptionSimulation.SimulatedHandPose.Max

Maksymalna prawidłowa wartość elementu SimulatedHandPose.

Microsoft.PerceptionSimulation.PlaybackState

Opisuje stan odtwarzania.

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

Microsoft.PerceptionSimulation.PlaybackState.Stopped

Nagranie jest obecnie zatrzymane i gotowe do odtwarzania.

Microsoft.PerceptionSimulation.PlaybackState.Playing

Nagranie jest obecnie odtwarzane.

Microsoft.PerceptionSimulation.PlaybackState.Paused

Nagranie jest obecnie wstrzymane.

Microsoft.PerceptionSimulation.PlaybackState.End

Nagranie osiągnęło koniec.

Microsoft.PerceptionSimulation.Vector3

Opisuje trzy wektory składników, które mogą opisywać punkt lub wektor w przestrzeni 3D.

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

Microsoft.PerceptionSimulation.Vector3.X

Składnik X wektora.

Microsoft.PerceptionSimulation.Vector3.Y

Składnik Y wektora.

Microsoft.PerceptionSimulation.Vector3.Z

Składnik Z wektora.

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

Skonstruuj nowy wektor3.

Parametry

x — składnik x wektora.
y — składnik y wektora.
z — składnik z wektora.

Microsoft.PerceptionSimulation.Rotation3

Opisuje rotację trzech składników.

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

Microsoft.PerceptionSimulation.Rotation3.Pitch

Składnik Pitch obrotu w dół wokół osi X.

Microsoft.PerceptionSimulation.Rotation3.Yaw

Składnik Yaw rotacji w prawo wokół osi Y.

Microsoft.PerceptionSimulation.Rotation3.Roll

Składnik Roll w rotacji w prawo wokół osi Z.

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

Skonstruuj nową rotację3.

Parametry

pitch — składnik skoku rotacji.
yaw — składnik yaw rotacji.
roll — składnik rzutowania rotacji.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration

Opisuje konfigurację stawu pod symulowaną ręką.

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

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.Position

Położenie stawu.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.Rotation

Obrót stawu.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.TrackingAccuracy

Dokładność śledzenia stawu.

Microsoft.PerceptionSimulation.Frustum

Opisuje frustum widoku, jak zwykle używane przez kamerę.

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

Microsoft.PerceptionSimulation.Frustum.Near

Minimalna odległość zawarta w frustum.

Microsoft.PerceptionSimulation.Frustum.Far

Maksymalna odległość zawarta w frustum.

Microsoft.PerceptionSimulation.Frustum.FieldOfView

Poziome pole widoku frustum, w radianach (mniej niż PI).

Microsoft.PerceptionSimulation.Frustum.AspectRatio

Stosunek pola poziomego widoku do pionowego pola widoku.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration

Opisuje konfigurację symulowanego zestawu słuchawkowego.

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

Transformacja z środka głowy do lewego oka na potrzeby renderowania stereo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.LeftEyeRotation

Obrót lewego oka na potrzeby renderowania stereo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyePosition

Transformacja z środka głowy do prawego oka na potrzeby renderowania stereo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyeRotation

Obracanie właściwego oka na potrzeby renderowania stereo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.Ipd

Wartość Ipd zgłoszona przez system na potrzeby renderowania stereo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyEyeTransforms

Czy wartości podane dla przekształceń lewego i prawego oka powinny być uznawane za prawidłowe i stosowane do działającego systemu.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyIpd

Czy wartość podana dla adresu Ipd powinna być uważana za prawidłową i zastosowaną do działającego systemu.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager

Katalog główny służący do generowania pakietów używanych do kontrolowania urządzenia.

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

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Device

Pobierz symulowany obiekt urządzenia, który interpretuje symulowany człowiek i symulowany świat.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Human

Pobierz obiekt, który kontroluje symulowanego człowieka.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Reset

Resetuje symulację do stanu domyślnego.

Microsoft.PerceptionSimulation.ISimulatedDevice

Interfejs opisujący urządzenie, które interpretuje symulowany świat i symulowanego człowieka

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

Microsoft.PerceptionSimulation.ISimulatedDevice.HeadTracker

Pobierz monitor head tracker z symulowanego urządzenia.

Microsoft.PerceptionSimulation.ISimulatedDevice.HandTracker

Pobierz monitor ręczny z urządzenia symulowanego.

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

Ustaw właściwości symulowanego urządzenia zgodnie z podanym typem urządzenia.

Parametry

type — nowy typ urządzenia symulowanego

Microsoft.PerceptionSimulation.ISimulatedDevice2

Dodatkowe właściwości są dostępne przez rzutowanie ISimulatedDevice na ISimulatedDevice2

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

};

Microsoft.PerceptionSimulation.ISimulatedDevice2.IsUserPresent

Pobierz lub ustaw, czy symulowany człowiek aktywnie nosi zestaw słuchawkowy.

Microsoft.PerceptionSimulation.ISimulatedDevice2.DisplayConfiguration

Pobierz lub ustaw właściwości symulowanego ekranu.

Microsoft.PerceptionSimulation.ISimulatedHeadTracker

Interfejs opisujący część symulowanego urządzenia, który śledzi głowę symulowanego człowieka.

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

Microsoft.PerceptionSimulation.ISimulatedHeadTracker.HeadTrackerMode

Pobiera i ustawia bieżący tryb monitora głowy.

Microsoft.PerceptionSimulation.ISimulatedHandTracker

Interfejs opisujący część symulowanego urządzenia, który śledzi ręce symulowanego człowieka

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

Pobierz położenie węzła z relacją ze światem w metrach.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Position

Pobierz i ustaw położenie symulowanego monitora rąk względem środka głowy.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Pitch

Pobierz i ustaw skok w dół symulowanego trackera ręki.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Frustum Ignorowane

Pobierz i ustaw, czy frustum symulowanego monitora rąk jest ignorowane. Po zignorowaniu obie ręce są zawsze widoczne. Gdy nie są ignorowane (domyślne) ręce są widoczne tylko wtedy, gdy znajdują się one w frustum monitora dłoni.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Frustum

Pobierz i ustaw właściwości frustum używane do określenia, czy ręce są widoczne dla symulowanego monitora rąk.

Microsoft.PerceptionSimulation.ISimulatedHuman

Interfejs najwyższego poziomu do kontrolowania symulowanego człowieka.

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

Pobierz i ustaw położenie węzła z relacją ze światem w metrach. Pozycja odpowiada punktowi w środku stóp człowieka.

Microsoft.PerceptionSimulation.ISimulatedHuman.Direction

Pobierz i ustaw kierunek symulowanych ludzkich twarzy na świecie. 0 radianów stoi w dół ujemnej osi Z. Dodatnie radiany obracają się zgodnie z ruchem wskazówek zegara na osi Y.

Microsoft.PerceptionSimulation.ISimulatedHuman.Height

Pobierz i ustaw wysokość symulowanego człowieka w metrach.

Microsoft.PerceptionSimulation.ISimulatedHuman.LeftHand

Pobierz lewą rękę symulowanego człowieka.

Microsoft.PerceptionSimulation.ISimulatedHuman.RightHand

Pobierz prawą rękę symulowanego człowieka.

Microsoft.PerceptionSimulation.ISimulatedHuman.Head

Pobierz głowę symulowanego człowieka.

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

Przenieś symulowanego człowieka względem bieżącej pozycji w metrach.

Parametry

translation — tłumaczenie, które ma zostać przeniesione względem bieżącego położenia.

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

Obraca symulowany człowiek względem jego bieżącego kierunku, zgodnie z ruchem wskazówek zegara na osi Y

Parametry

radiany — kwota obracania się wokół osi Y.

Microsoft.PerceptionSimulation.ISimulatedHuman2

Dodatkowe właściwości są dostępne przez odlewanie ISimulatedHuman do ISimulatedHuman2

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

Microsoft.PerceptionSimulation.ISimulatedHuman2.LeftController

Pobierz lewy kontroler 6-DOF.

Microsoft.PerceptionSimulation.ISimulatedHuman2.RightController

Pobierz odpowiedni kontroler 6-DOF.

Microsoft.PerceptionSimulation.ISimulatedHand

Interfejs opisujący rękę symulowanego człowieka

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

Pobierz położenie węzła z relacją ze światem w metrach.

Microsoft.PerceptionSimulation.ISimulatedHand.Position

Pobierz i ustaw położenie symulowanej ręki względem człowieka, w metrach.

Microsoft.PerceptionSimulation.ISimulatedHand.Activated

Pobierz i ustaw, czy ręka jest obecnie aktywowana.

Microsoft.PerceptionSimulation.ISimulatedHand.Visible

Pobierz, czy ręka jest obecnie widoczna dla urządzenia SimulatedDevice (oznacza to, czy znajduje się ona w pozycji do wykrycia przez handTracker).

Microsoft.PerceptionSimulation.ISimulatedHand.EnsureVisible

Przenieś rękę tak, aby była widoczna dla urządzenia SimulatedDevice.

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

Przenieś położenie symulowanej ręki względem bieżącej pozycji w metrach.

Parametry

translation — kwota tłumaczenia symulowanej ręki.

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

Wykonaj gest przy użyciu symulowanej ręki. Zostanie wykryta tylko przez system, jeśli ręka jest włączona.

Parametry

gest — gest do wykonania.

Microsoft.PerceptionSimulation.ISimulatedHand2

Dodatkowe właściwości są dostępne przez rzutowanie ISimulatedHand do ISimulatedHand2.

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

Microsoft.PerceptionSimulation.ISimulatedHand2.Orientation

Pobierz lub ustaw rotację symulowanej ręki. Dodatnie radiany obracają się zgodnie z ruchem wskazówek zegara podczas patrzenia wzdłuż osi.

Microsoft.PerceptionSimulation.ISimulatedHand3

Dodatkowe właściwości są dostępne przez rzutowanie ISimulatedHand do 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

Pobierz wspólną konfigurację określonego stawu.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetJointConfiguration

Ustaw wspólną konfigurację dla określonego stawu.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetHandPose

Ustaw rękę na znaną pozę z opcjonalną flagą, aby animować. Uwaga: animowanie nie spowoduje natychmiastowego odzwierciedlenia ich końcowych konfiguracji stawowych.

Microsoft.PerceptionSimulation.ISimulatedHead

Interfejs opisujący głowę symulowanego człowieka.

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

Microsoft.PerceptionSimulation.ISimulatedHead.WorldPosition

Pobierz położenie węzła z relacją ze światem w metrach.

Microsoft.PerceptionSimulation.ISimulatedHead.Rotation

Pobierz rotację symulowanej głowy. Dodatnie radiany obracają się zgodnie z ruchem wskazówek zegara podczas patrzenia wzdłuż osi.

Microsoft.PerceptionSimulation.ISimulatedHead.Średnica

Pobierz średnicę symulowanej głowy. Ta wartość służy do określania środka głowy (punktu rotacji).

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

Obraca symulowaną głowę względem bieżącej rotacji. Dodatnie radiany obracają się zgodnie z ruchem wskazówek zegara podczas patrzenia wzdłuż osi.

Parametry

rotacja — kwota do rotacji.

Microsoft.PerceptionSimulation.ISimulatedHead2

Dodatkowe właściwości są dostępne przez rzutowanie elementu ISimulatedHead na ISimulatedHead2

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

Microsoft.PerceptionSimulation.ISimulatedHead2.Eyes

Pobierz oczy symulowanego człowieka.

Microsoft.PerceptionSimulation.ISimulatedSixDofController

Interfejs opisujący kontroler 6-DOF skojarzony z symulowanym człowiekiem.

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

Pobierz położenie węzła z relacją ze światem w metrach.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Status

Pobierz lub ustaw bieżący stan kontrolera. Stan kontrolera musi być ustawiony na wartość inną niż Wyłączone, zanim wszystkie wywołania do przenoszenia, obracania lub naciśnięcia przycisków powiedzie się.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Position

Pobierz lub ustaw położenie symulowanego kontrolera względem człowieka w metrach.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Orientation

Pobierz lub ustaw orientację symulowanego kontrolera.

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

Przenieś położenie symulowanego kontrolera względem jego bieżącej pozycji w metrach.

Parametry

translation — kwota tłumaczenia symulowanego kontrolera.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.PressButton(SimulatedSixDofControllerButton)

Naciśnij przycisk na symulowanym kontrolerze. Zostanie wykryta tylko przez system, jeśli kontroler jest włączony.

Parametry

button — przycisk do naciśnięcia.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.ReleaseButton(SimulatedSixDofControllerButton)

Zwolnij przycisk na symulowanym kontrolerze. Zostanie wykryta tylko przez system, jeśli kontroler jest włączony.

Parametry

button — przycisk do zwolnienia.

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

Uzyskaj położenie symulowanego palca na symulowanym kontrolerze touchpad.

Parametry

x — położenie poziome palca.
y — pionowa pozycja palca.

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

Ustaw położenie symulowanego palca na symulowanym panelu dotykowym kontrolera.

Parametry

x - pozycja pozioma palca.
y - położenie pionowego palca.

Microsoft.PerceptionSimulation.ISimulatedSixDofController2

Dodatkowe właściwości i metody są dostępne przez rzutowanie interfejsu ISimulatedSixDofController do interfejsu 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)

Pobierz położenie symulowanego kciuka na symulowanym kontrolerze.

Parametry

x — pozycja pozioma szminki.
y — położenie pionowej szminki.

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

Ustaw położenie symulowanego kciuka na symulowanym kontrolerze.

Parametry

x — pozycja pozioma szminki.
y — położenie pionowej szminki.

Microsoft.PerceptionSimulation.ISimulatedSixDofController2.BatteryLevel

Pobierz lub ustaw poziom baterii symulowanego kontrolera. Wartość musi być większa niż 0,0 i mniejsza niż lub równa 100,0.

Microsoft.PerceptionSimulation.ISimulatedEyes

Interfejs opisujący oczy symulowanego człowieka.

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

Microsoft.PerceptionSimulation.ISimulatedEyes.Rotation

Pobierz obrót symulowanych oczu. Dodatnie radiany obracają się zgodnie z ruchem wskazówek zegara podczas patrzenia wzdłuż osi.

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

Obraca symulowane oczy względem bieżącej rotacji. Dodatnie radiany obracają się zgodnie z ruchem wskazówek zegara podczas patrzenia wzdłuż osi.

Parametry

rotacja — kwota, która ma być obracana.

Microsoft.PerceptionSimulation.ISimulatedEyes.CalibrationState

Pobiera lub ustawia stan kalibracji symulowanych oczu.

Microsoft.PerceptionSimulation.ISimulatedEyes.WorldPosition

Pobierz położenie węzła z relacją ze światem w metrach.

Microsoft.PerceptionSimulation.ISimulationRecording

Interfejs do interakcji z jednym nagraniem załadowanym do odtwarzania.

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

Microsoft.PerceptionSimulation.ISimulationRecording.DataTypes

Pobiera listę typów danych w nagraniu.

Microsoft.PerceptionSimulation.ISimulationRecording.State

Pobiera bieżący stan nagrania.

Microsoft.PerceptionSimulation.ISimulationRecording.Play

Uruchom odtwarzanie. Jeśli nagranie zostanie wstrzymane, odtwarzanie zostanie wznowione z wstrzymanej lokalizacji; jeśli zostanie zatrzymany, odtwarzanie rozpocznie się na początku. Jeśli to połączenie jest już odtwarzane, jest ignorowane.

Microsoft.PerceptionSimulation.ISimulationRecording.Pause

Wstrzymuje odtwarzanie w bieżącej lokalizacji. Jeśli nagranie zostanie zatrzymane, wywołanie zostanie zignorowane.

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

Szuka nagrania do określonego czasu (w 100-nanosekundach interwałów od początku) i wstrzymuje się w tej lokalizacji. Jeśli czas przekracza koniec nagrania, jest wstrzymany w ostatniej klatce.

Parametry

kleszcze - czas, do którego należy szukać.

Microsoft.PerceptionSimulation.ISimulationRecording.Stop

Zatrzymuje odtwarzanie i resetuje położenie do początku.

Microsoft.PerceptionSimulation.ISimulationRecordingCallback

Interfejs do odbierania zmian stanu podczas odtwarzania.

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

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

Wywoływana po zmianie stanu odtwarzania ISimulationRecording.

Parametry

newState — nowy stan nagrania.

Microsoft.PerceptionSimulation.PerceptionSimulationManager

Obiekt główny do tworzenia obiektów symulacji percepcji.

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)

Utwórz obiekt na potrzeby generowania symulowanych pakietów i dostarczania ich do dostarczonego ujścia.

Parametry

sink — ujście, które będzie odbierać wszystkie wygenerowane pakiety.

Wartość zwracana

Utworzony menedżer.

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

Utwórz ujście, które przechowuje wszystkie odebrane pakiety w pliku w określonej ścieżce.

Parametry

path — ścieżka pliku do utworzenia.

Wartość zwracana

Utworzony ujście.

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

Załaduj nagranie z określonego pliku.

Parametry

path — ścieżka pliku do załadowania.
factory — fabryka używana przez nagranie do tworzenia ISimulationStreamSink, jeśli jest to wymagane.

Wartość zwracana

Załadowane nagranie.

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

Załaduj nagranie z określonego pliku.

Parametry

path — ścieżka pliku do załadowania.
factory — fabryka używana przez nagranie do tworzenia ISimulationStreamSink, jeśli jest to wymagane.
wywołanie zwrotne — wywołanie zwrotne, które odbiera aktualizacje ponownej klasyfikacji stanu nagrania.

Wartość zwracana

Załadowane nagranie.

Microsoft.PerceptionSimulation.StreamDataTypes

Opisuje różne typy danych strumienia.

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

Wartość sentinel używana do wskazywania brak typów danych strumienia.

Microsoft.PerceptionSimulation.StreamDataTypes.Head

Strumień danych dla położenia i orientacji głowy.

Microsoft.PerceptionSimulation.StreamDataTypes.Hands

Strumień danych dla położenia i gestów rąk.

Microsoft.PerceptionSimulation.StreamDataTypes.SpatialMapping

Strumień danych do mapowania przestrzennego środowiska.

Microsoft.PerceptionSimulation.StreamDataTypes.Calibration

Strumień danych do kalibracji urządzenia. Pakiety kalibracji są akceptowane tylko przez system w trybie zdalnym.

Microsoft.PerceptionSimulation.StreamDataTypes.Environment

Strumień danych dla środowiska urządzenia.

Microsoft.PerceptionSimulation.StreamDataTypes.SixDofControllers

Strumień danych dla kontrolerów ruchu.

Microsoft.PerceptionSimulation.StreamDataTypes.Eyes

Strumień danych z oczami symulowanego człowieka.

Microsoft.PerceptionSimulation.StreamDataTypes.DisplayConfiguration

Strumień danych z konfiguracją wyświetlania urządzenia.

Microsoft.PerceptionSimulation.StreamDataTypes.All

Wartość sentinel używana do wskazywania wszystkich zarejestrowanych typów danych.

Microsoft.PerceptionSimulation.ISimulationStreamSink

Obiekt, który odbiera pakiety danych ze strumienia symulacji.

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

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

Odbiera pojedynczy pakiet, który jest wpisany wewnętrznie i w wersji.

Parametry

length — długość pakietu.
packet — dane pakietu.

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory

Obiekt, który tworzy ISimulationStreamSink.

public interface ISimulationStreamSinkFactory
{
    ISimulationStreamSink CreateSimulationStreamSink();
}

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory.CreateSimulationStreamSink()

Tworzy pojedyncze wystąpienie ISimulationStreamSink.

Wartość zwracana

Utworzony ujście.

Symulacja percepcji

Konfigurowanie projektu programu Visual Studio na potrzeby symulacji percepcji

Tworzenie obiektu menedżera IPerceptionSimulation

Kontrolowanie symulowanego człowieka

Podstawowa przykładowa aplikacja konsolowa języka C#

Rozszerzona przykładowa aplikacja konsolowa języka C#

Uwaga dotycząca kontrolerów 6-DOF

Dokumentacja interfejsu API

Microsoft.PerceptionSimulation.SimulatedDeviceType

Microsoft.PerceptionSimulation.HeadTrackerMode

Microsoft.PerceptionSimulation.SimulatedGesture

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy

Microsoft.PerceptionSimulation.SimulatedHandPose

Microsoft.PerceptionSimulation.PlaybackState

Microsoft.PerceptionSimulation.Vector3

Microsoft.PerceptionSimulation.Rotation3

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration

Microsoft.PerceptionSimulation.Frustum

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration

Microsoft.PerceptionSimulation.IPerceptionSimulationManager

Microsoft.PerceptionSimulation.ISimulatedDevice

Microsoft.PerceptionSimulation.ISimulatedDevice2

Microsoft.PerceptionSimulation.ISimulatedHeadTracker

Microsoft.PerceptionSimulation.ISimulatedHandTracker

Microsoft.PerceptionSimulation.ISimulatedHuman

Microsoft.PerceptionSimulation.ISimulatedHuman2

Microsoft.PerceptionSimulation.ISimulatedHand

Microsoft.PerceptionSimulation.ISimulatedHand2

Microsoft.PerceptionSimulation.ISimulatedHand3

Microsoft.PerceptionSimulation.ISimulatedHead

Microsoft.PerceptionSimulation.ISimulatedHead2

Microsoft.PerceptionSimulation.ISimulatedSixDofController

Microsoft.PerceptionSimulation.ISimulatedSixDofController2

Microsoft.PerceptionSimulation.ISimulatedEyes

Microsoft.PerceptionSimulation.ISimulationRecording

Microsoft.PerceptionSimulation.ISimulationRecordingCallback

Microsoft.PerceptionSimulation.PerceptionSimulationManager

Microsoft.PerceptionSimulation.StreamDataTypes

Microsoft.PerceptionSimulation.ISimulationStreamSink

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory

Dodatkowe zasoby