Symulacja percepcji

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żesz 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 urządzenia 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

  1. Zainstaluj emulator urządzenia HoloLens na komputerze dewelopera. Emulator zawiera biblioteki używane do symulacji percepcji.

  2. Tworzenie nowego projektu klasycznego programu Visual Studio C# (projekt konsoli działa świetnie, aby rozpocząć pracę).

  3. 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 urządzenia 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.

  4. 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.
    Dodawanie PerceptionSimulationManager.dll do projektu jako linku

    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.
    Oznacz PerceptionSimulationManager.dll, aby skopiować do katalogu wyjściowego

  5. 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 go 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. 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 obrotu w prawo wokół osi Y.

Microsoft.PerceptionSimulation.Rotation3.Roll

Składnik rzutowania obrotu 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 obrotu.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration

Opisuje konfigurację połączenia z 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, który jest zwykle używany przez aparat fotograficzny.

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 (mniejsze niż PI).

Microsoft.PerceptionSimulation.Frustum.AspectRatio

Stosunek pola poziomego widoku do pola pionowego widoku.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration

Opisuje konfigurację symulowanego zestawu nagłownego.

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

Przekształcenie od środka głowy do prawego oka do celów renderowania stereo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyeRotation

Obrót prawego oka do celów 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

Określa, czy wartość podana dla adresu IPd powinna być uznawana za prawidłową i zastosowaną do uruchomionego systemu.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager

Katalog główny 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 obiekt urządzenia symulowanego, 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 urządzenia symulowanego.

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 tak, aby odpowiadały podanemu typowi urządzenia.

Parametry

  • type — nowy typ urządzenia symulowanego

Microsoft.PerceptionSimulation.ISimulatedDevice2

Dodatkowe właściwości są dostępne przez rzutowanie interfejsu ISimulatedDevice na urządzenie 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 wyświetlania.

Microsoft.PerceptionSimulation.ISimulatedHeadTracker

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

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

Microsoft.PerceptionSimulation.ISimulatedHeadTracker.HeadTrackerMode

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

Microsoft.PerceptionSimulation.ISimulatedHandTracker

Interfejs opisujący część symulowanego urządzenia, która ś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ęki względem środka głowy.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Pitch

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

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Frustum Ignoruj

Pobierz i ustaw, czy frustum symulowanego monitora ręcznego 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ę w frustum monitora ręki.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Frustum

Pobierz i ustaw właściwości frustum używane do określenia, czy ręce są widoczne dla symulowanego trackera 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

Pobieranie i ustawianie kierunku 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

Pobieraj i ustawiaj 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 kontrolerze touchpad.

Parametry

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

Microsoft.PerceptionSimulation.ISimulatedSixDofController2

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

Uzyskaj pozycję symulowanego kciuka na symulowanym kontrolerze.

Parametry

  • x — położenie poziome szminki.
  • y — położenie pionowej szminki.

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

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

Parametry

  • x — położenie poziome 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 rotację 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 do rotacji.

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 umożliwiający interakcję z pojedynczym 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 od początku) i wstrzymuje się w tej lokalizacji. Jeśli czas przekracza koniec nagrania, zostanie wstrzymany na ostatniej klatce.

Parametry

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

Microsoft.PerceptionSimulation.ISimulationRecording.Stop

Zatrzymuje odtwarzanie i resetuje położenie na 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, gdy stan odtwarzania ISimulationRecording został zmieniony.

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 otrzyma 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 nagrywanie 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 nagrywanie do tworzenia ISimulationStreamSink, jeśli jest to wymagane.
  • wywołanie zwrotne — wywołanie zwrotne, które odbiera aktualizacje ponownego oceniania 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 żadnych 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 pozycji i gestów dłoni.

Microsoft.PerceptionSimulation.StreamDataTypes.SpatialMapping

Strumień danych na potrzeby 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.