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ładników 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. Można na przykład zasymulować dane wejściowe człowieka patrzącego na określoną, powtarzalną pozycję, 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 rzeczywistości mieszanej. Symulacja percepcji pomija czujniki na żywo na urządzeniu rzeczywistości mieszanej i wysyła symulowane dane wejściowe do aplikacji uruchomionych 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ą odróżnić działania z rzeczywistymi czujnikami a symulacją percepcji. Symulacja percepcji to ta sama technologia używana przez emulatory urządzenia 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 w celu kontrolowania właściwości symulowanego "człowieka", w tym pozycji głowy, położenia dłoni i gestów. 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 deweloperów. Emulator zawiera biblioteki używane do symulacji percepcji.
Tworzenie nowego projektu klasycznego programu Visual Studio C# (projekt konsoli doskonale nadaje się do rozpoczęcia pracy).
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 urządzenia HoloLens 2.

Uwaga

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

a. PerceptionSimulationManager.Interop.dll — zarządzana otoka języka C# na potrzeby symulacji percepcji.
b. PerceptionSimulationRest.dll — biblioteka konfigurowania kanału komunikacyjnego gniazda internetowego na urządzeniu HoloLens lub emulatorze.
c. SimulationStream.Interop.dll — udostępnione typy 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 kopiować go do folderu źródłowego projektu.

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

Tworzenie obiektu menedżera IPerceptionSimulation

Aby kontrolować symulację, wydasz 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ądzenia na pasku narzędzi

Otwórz ikonę Portalu urządzeń Otwórz portal urządzeń: otwórz portal urządzeń z systemem Windows dla systemu operacyjnego HoloLens w emulatorze. W przypadku środowiska Windows Mixed Reality można to pobrać w aplikacji Ustawienia w obszarze "Aktualizacja i zabezpieczenia", a następnie "Dla deweloperów" w sekcji "Łączenie 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 będą przekazywane do portalu urządzeń z systemem Windows uruchomionego na urządzeniu lub emulatorze i obsługiwane przez portal urządzeń z systemem Windows. 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 jego 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ć wartość true dla scenariuszy testowych, co umożliwia testowi przejęcie kontroli. W emulatorze i symulacji windows Mixed Reality są używane połączenia o niskim priorytcie. Jeśli test używa również połączenia o niskim priorytcie, ostatnio nawiązane połączenie będzie w kontrolce.
Token System.Threading.CancellationToken — token umożliwiający anulowanie operacji asynchronicznych.

Następnie 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 = właściwy kontroler 6-DOF

Kod zakończenia procesu będzie wskazywać powodzenie (wartość zerowa zwracana) lub niepowodzenie (wartość zwracana niezerowo). W przypadku używania akcji "q" w celu wykonania zapytania o to, czy kontroler jest zainstalowany, zwracana wartość będzie równa 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 wcześniejszym 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 śledzenia 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

Śledzenie tylko orientacji głowy. Oznacza to, że śledzone położenie może nie być niezawodne, a niektóre funkcje zależne od pozycji głowy mogą być niedostępne.

Microsoft.PerceptionSimulation.HeadTrackerMode.Position

Śledzenie głowicy pozycyjnej. Oznacza to, że śledzone położenie i orientacja głowy 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 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

Naciśnięty jest przycisk Grip.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.TouchpadPress

Tablet TouchPad jest naciśnięty.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Select

Naciśnięcie przycisku Wybierz.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.TouchpadTouch

TouchPad jest dotykany.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Thumbstick

Naciśniętą szminkę.

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ą kalibrowane.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.UserCalibrationNeeded

Oczy muszą być skalibrowane.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy

Dokładność śledzenia stawów 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 stawów ręki.

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

Microsoft.PerceptionSimulation.SimulatedHandPose.Closed

Stawy palców dłoni są skonfigurowane do odzwierciedlenia zamkniętej pozy.

Microsoft.PerceptionSimulation.SimulatedHandPose.Open

Stawy palców dłoni są skonfigurowane do odzwierciedlenia otwartej pozy.

Microsoft.PerceptionSimulation.SimulatedHandPose.Point

Stawy palców dłoni są skonfigurowane do odzwierciedlenia punktowej pozy.

Microsoft.PerceptionSimulation.SimulatedHandPose.Pinch

Stawy palców dłoni są skonfigurowane do odzwierciedlenia szczypającej 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 dotarło do końca.

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 na symulowanej ręce.

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 aparat.

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 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

Transformacja z środka głowy do prawej strony do celów renderowania stereo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyeRotation

Rotacja prawego 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ć traktowane jako 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 uruchomionego 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 główny z urządzenia symulowanego.

Microsoft.PerceptionSimulation.ISimulatedDevice.HandTracker

Pobierz tracker ręki 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 urządzenia 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 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 śledzenia 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 Ignorowane

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

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 twarzy człowieka 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 być przenoszone względem bieżącego położenia.

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

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

Parametry

radiany — ilość obracana 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 stanie wykryć za pomocą rozwiązania HandTracker).

Microsoft.PerceptionSimulation.ISimulatedHand.EnsureVisible

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

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

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

Parametry

tłumaczenie — ilość do tłumaczenia symulowanej ręki.

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

Wykonaj gest przy użyciu symulowanej ręki. Zostanie on wykryty przez system tylko wtedy, gdy ręka jest włączona.

Parametry

gest — gest do wykonania.

Microsoft.PerceptionSimulation.ISimulatedHand2

Dodatkowe właściwości są dostępne przez rzutowanie ISimulatedHand na 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 na 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ę dla określonego połączenia.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetJointConfiguration

Ustaw wspólną konfigurację dla określonego połączenia.

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.Diameter

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

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 wartość 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 naciskania 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 bieżącej pozycji w metrach.

Parametry

translation — ilość do tłumaczenia symulowanego kontrolera.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.PressButton(SimulatedSixDofControllerButton)

Naciśnij przycisk na symulowanym kontrolerze. Zostanie on wykryty przez system tylko wtedy, gdy kontroler jest włączony.

Parametry

button — przycisk do naciśnięcia.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.ReleaseButton(SimulatedSixDofControllerButton)

Zwolnij przycisk na symulowanym kontrolerze. Zostanie on wykryty przez system tylko wtedy, gdy kontroler jest włączony.

Parametry

button — przycisk do zwolnienia.

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

Uzyskaj pozycję symulowanego palca na symulowanym panelu dotykowym kontrolera.

Parametry

x — położenie w poziomie palca.
y — położenie w pionie palca.

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

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

Parametry

x — położenie w poziomie palca.
y — położenie w pionie 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)

Uzyskaj pozycję symulowanego szminki 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 szminki 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

Pobiera 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 jego 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 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 jest już odtwarzane, to wywołanie 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 w ostatniej klatce.

Parametry

kleszcze - 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 uległ zmianie.

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 do załadowania pliku.
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 do załadowania pliku.
factory — fabryka używana przez nagranie 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 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 wersjonowany.

Parametry

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

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory

Obiekt, który tworzy element ISimulationStreamSink.

public interface ISimulationStreamSinkFactory
{
    ISimulationStreamSink CreateSimulationStreamSink();
}

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory.CreateSimulationStreamSink()

Tworzy pojedyncze wystąpienie ISimulationStreamSink.

Wartość zwracana

Utworzony ujście.

Udostępnij za pośrednictwem

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