Simulazione della percezione

Si vuole creare un test automatizzato per l'app? Si vuole che i test vadano oltre gli unit test a livello di componente ed eserci realmente l'app end-to-end? La simulazione della percezione è ciò che stai cercando. La libreria Perception Simulation invia dati di input umani e mondiali all'app in modo da automatizzare i test. Ad esempio, è possibile simulare l'input di un essere umano che cerca una posizione specifica ripetibile e quindi usare un movimento o un controller di movimento.

Perception Simulation può inviare input simulato come questo a un dispositivo HoloLens fisico, all'emulatore HoloLens (prima generazione), all'emulatore HoloLens 2 o a un PC con Realtà mista Portal installato. Perception Simulation ignora i sensori in tempo reale in un dispositivo Realtà mista e invia input simulato alle applicazioni in esecuzione nel dispositivo. Le applicazioni ricevono questi eventi di input tramite le stesse API che usano sempre e non possono indicare la differenza tra l'esecuzione con sensori reali e la simulazione della percezione. Perception Simulation è la stessa tecnologia usata dagli emulatori HoloLens per inviare input simulato alla macchina virtuale HoloLens.

Per iniziare a usare la simulazione nel codice, iniziare creando un oggetto IPerceptionSimulationManager. Da tale oggetto, è possibile eseguire comandi per controllare le proprietà di un "umano" simulato, tra cui posizione della testa, posizione della mano e movimenti. È anche possibile abilitare e modificare i controller del movimento.

Configurazione di un progetto di Visual Studio per la simulazione della percezione

1. Installare l'emulatore HoloLens nel PC di sviluppo. L'emulatore include le librerie usate per la simulazione della percezione.

2. Creare un nuovo progetto desktop C# di Visual Studio (un progetto console è ideale per iniziare).

3. Aggiungere i file binari seguenti al progetto come riferimenti (Project-Add-Reference>>...). È possibile trovarli in %ProgramFiles(x86)%\Microsoft XDE\(version), ad esempio %ProgramFiles(x86)%\Microsoft XDE\10.0.18362.0 per l'emulatore HoloLens 2.

   Nota

   Anche se i file binari fanno parte dell'emulatore HoloLens 2, funzionano anche per Windows Realtà mista sul desktop.

   a. PerceptionSimulationManager.Interop.dll - Wrapper C# gestito per la simulazione della percezione.
   b. PerceptionSimulationRest.dll : libreria per la configurazione di un canale di comunicazione web-socket per HoloLens o l'emulatore.
   c. SimulationStream.Interop.dll : tipi condivisi per la simulazione.

4. Aggiungere il PerceptionSimulationManager.dll binario di implementazione al progetto

   a. Prima di tutto aggiungerlo come file binario al progetto (Project-Add-Existing>> Item...). Salvarlo come collegamento in modo che non lo copia nella cartella di origine del progetto.
   

   b. Assicurarsi quindi che venga copiato nella cartella di output alla compilazione. Si trova nella finestra delle proprietà per il file binario.
   

5. Impostare la piattaforma della soluzione attiva su x64. Usare Configuration Manager per creare una voce Platform per x64 se non ne esiste già una.

Creazione di un oggetto IPerceptionSimulation Manager

Per controllare la simulazione, verranno distribuiti aggiornamenti agli oggetti recuperati da un oggetto IPerceptionSimulationManager. Il primo passaggio consiste nel ottenere tale oggetto e connetterlo al dispositivo o all'emulatore di destinazione. È possibile ottenere l'indirizzo IP dell'emulatore facendo clic sul pulsante Portale di dispositivi sulla barra degli strumenti

Aprire Portale di dispositivi: aprire Il portale di dispositivi di Windows per il sistema operativo HoloLens nell'emulatore. Per Windows Realtà mista, questo può essere recuperato nell'app Impostazioni in "Update & Security", quindi "Per gli sviluppatori" nella sezione "Connetti con:" in "Abilita Portale di dispositivi". Assicurarsi di prendere nota sia dell'indirizzo IP che della porta.

Prima di tutto, chiamerai RestSimulationStreamSink.Create per ottenere un oggetto RestSimulationStreamSink. Si tratta del dispositivo o dell'emulatore di destinazione che si controlla su una connessione HTTP. I comandi verranno passati a e gestiti da Windows Device Portal in esecuzione nel dispositivo o nell'emulatore. I quattro parametri necessari per creare un oggetto sono:

• URI URI : indirizzo IP del dispositivo di destinazione (ad esempio, "https://123.123.123.123" o "https://123.123.123.123:50080")
• Credenziali System.Net.NetworkCredential - Nome utente/password per la connessione al portale di dispositivi di Windows nel dispositivo o nell'emulatore di destinazione. Se ci si connette all'emulatore tramite l'indirizzo locale, ad esempio 168... *) sullo stesso PC, tutte le credenziali verranno accettate.
• bool normal- True per la priorità normale, false per priorità bassa. In genere si vuole impostare questa opzione su true per gli scenari di test, che consente al test di assumere il controllo. L'emulatore e la simulazione di Windows Realtà mista usano connessioni con priorità bassa. Se il test usa anche una connessione con priorità bassa, la connessione stabilita più di recente sarà in controllo.
• Token System.Threading.CancellationToken: token per annullare l'operazione asincrona.

In secondo luogo, si creerà IPerceptionSimulationManager. Si tratta dell'oggetto usato per controllare la simulazione. Questa operazione deve essere eseguita anche in un metodo asincrono.

Controllare l'essere umano simulato

Un oggetto IPerceptionSimulationManager ha una proprietà Human che restituisce un oggetto ISimulatedHuman. Per controllare l'essere umano simulato, eseguire operazioni su questo oggetto. Ad esempio:

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

Applicazione console C# di esempio di base

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

Applicazione console C# di esempio estesa

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

Nota sui controller DOF 6

Prima di chiamare qualsiasi proprietà sui metodi in un controller 6-DOF simulato, è necessario attivare il controller. In caso contrario, verrà generata un'eccezione. A partire dalla Aggiornamento di Windows 10 (maggio 2019), è possibile installare e attivare controller 6-DOF simulati impostando la proprietà Status sull'oggetto ISimulatedSixDofController su SimulatedSixDofControllerStatus.Active. Nella Aggiornamento di Windows 10 (ottobre 2018) e versioni precedenti è necessario installare separatamente un controller 6-DOF simulato chiamando prima lo strumento PerceptionSimulationDevice che si trova nella cartella \Windows\System32. L'utilizzo di questo strumento è il seguente:

    PerceptionSimulationDevice.exe <action> 6dof <instance>

Ad esempio:

    PerceptionSimulationDevice.exe i 6dof 1

Le azioni supportate sono:

• i = installazione
• q = query
• r = remove

Le istanze supportate sono:

• 1 = il controller DOF a sinistra
• 2 = il controller 6-DOF destro

Il codice di uscita del processo indicherà l'esito positivo (un valore restituito zero) o un errore (un valore restituito diverso da zero). Quando si usa l'azione 'q' per eseguire una query su se è installato un controller, il valore restituito sarà zero (0) se il controller non è già installato o uno (1) se il controller è installato.

Quando si rimuove un controller nel Aggiornamento di Windows 10 (ottobre 2018) o versioni precedenti, impostarne lo stato su Disattivato prima tramite l'API, quindi chiamare lo strumento PerceptionSimulationDevice.

Questo strumento deve essere eseguito come amministratore.

Informazioni di riferimento sulle API

Microsoft.PerceptionSimulation.SimulatedDeviceType

Descrive un tipo di dispositivo simulato

public enum SimulatedDeviceType
{
    Reference = 0
}

Microsoft.PerceptionSimulation.SimulatedDeviceType.Reference

Un dispositivo di riferimento fittizio, il valore predefinito per PerceptionSimulationManager

Microsoft.PerceptionSimulation.HeadTrackerMode

Descrive una modalità di tracciamento della testa

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

Microsoft.PerceptionSimulation.HeadTrackerMode.Default

Tracciamento della testa predefinito. Ciò significa che il sistema può selezionare la modalità di rilevamento head migliore in base alle condizioni di runtime.

Microsoft.PerceptionSimulation.HeadTrackerMode.Orientation

Orientamento solo tracciamento testa. Ciò significa che la posizione rilevata potrebbe non essere affidabile e alcune funzionalità dipendenti dalla posizione della testa potrebbero non essere disponibili.

Microsoft.PerceptionSimulation.HeadTrackerMode.Position

Tracciamento testa posizionale. Ciò significa che la posizione e l'orientamento della testa tracciati sono entrambi affidabili

Microsoft.PerceptionSimulation.SimulatedGesture

Descrive un gesto simulato

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

Microsoft.PerceptionSimulation.SimulatedGesture.None

Valore sentinel utilizzato per indicare nessun movimento.

Microsoft.PerceptionSimulation.SimulatedGesture.FingerPressed

Un gesto premuto dal dito.

Microsoft.PerceptionSimulation.SimulatedGesture.FingerReleased

Un gesto rilasciato da un dito.

Microsoft.PerceptionSimulation.SimulatedGesture.Home

Movimento home/system.

Microsoft.PerceptionSimulation.SimulatedGesture.Max

Movimento massimo valido.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus

Stati possibili di un controller 6-DOF simulato.

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

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Off

Il controller 6-DOF è disattivato.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Active

Il controller 6-DOF viene attivato e monitorato.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.TrackingLost

Il controller 6-DOF è attivato, ma non può essere rilevato.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton

Pulsanti supportati in un controller 6-DOF simulato.

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

Valore sentinel usato per indicare nessun pulsante.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Home

Viene premuto il pulsante Home.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Menu

Viene premuto il pulsante Menu.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Grip

Viene premuto il pulsante Grip.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.TouchpadPress

Il TouchPad viene premuto.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Select

Viene premuto il pulsante Seleziona.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.TouchpadTouch

Il TouchPad viene toccato.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Thumbstick

La levetta viene premuta.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Max

Pulsante massimo valido.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState

Stato di calibrazione degli occhi simulati

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

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Unavailable

La calibrazione degli occhi non è disponibile.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Ready

Gli occhi sono stati calibrati. Questo è il valore predefinito.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Configuring

Gli occhi vengono calibrati.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.UserCalibrationNeeded

Gli occhi devono essere calibrati.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy

Accuratezza del tracciamento di un giunto della mano.

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

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Unavailable

Il giunto non è monitorato.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Approximate

La posizione comune è dedotta.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Visible

Il giunto è completamente tracciato.

Microsoft.PerceptionSimulation.SimulatedHandPose

Accuratezza del tracciamento di un giunto della mano.

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

Microsoft.PerceptionSimulation.SimulatedHandPose.Closed

Le articolazioni delle dita della mano sono configurate per riflettere una posa chiusa.

Microsoft.PerceptionSimulation.SimulatedHandPose.Open

Le articolazioni delle dita della mano sono configurate per riflettere una posa aperta.

Microsoft.PerceptionSimulation.SimulatedHandPose.Point

Le articolazioni delle dita della mano sono configurate per riflettere una posa puntante.

Microsoft.PerceptionSimulation.SimulatedHandPose.Pinch

Le articolazioni delle dita della mano sono configurate per riflettere una posa di avvicinamento delle dita.

Microsoft.PerceptionSimulation.SimulatedHandPose.Max

Valore massimo valido per SimulatedHandPose.

Microsoft.PerceptionSimulation.PlaybackState

Descrive lo stato di una riproduzione.

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

Microsoft.PerceptionSimulation.PlaybackState.Stopped

La registrazione è attualmente arrestata e pronta per la riproduzione.

Microsoft.PerceptionSimulation.PlaybackState.Playing

La registrazione è attualmente in riproduzione.

Microsoft.PerceptionSimulation.PlaybackState.Paused

La registrazione è attualmente sospesa.

Microsoft.PerceptionSimulation.PlaybackState.End

La registrazione ha raggiunto la fine.

Microsoft.PerceptionSimulation.Vector3

Descrive un vettore di tre componenti, che può descrivere un punto o un vettore nello spazio 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

Componente X del vettore.

Microsoft.PerceptionSimulation.Vector3.Y

Componente Y del vettore.

Microsoft.PerceptionSimulation.Vector3.Z

Componente Z del vettore.

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

Costruisci un nuovo Vector3.

Parametri

• x - Componente x del vettore.
• y : componente y del vettore.
• z : componente z del vettore.

Microsoft.PerceptionSimulation.Rotation3

Descrive una rotazione di tre componenti.

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

Microsoft.PerceptionSimulation.Rotation3.Pitch

Componente Inclinazione della rotazione, attorno all'asse X.

Microsoft.PerceptionSimulation.Rotation3.Yaw

Componente Yaw della rotazione, attorno all'asse Y.

Microsoft.PerceptionSimulation.Rotation3.Roll

Componente Roll della rotazione, attorno all'asse Z.

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

Costruire un nuovo oggetto Rotation3.

Parametri

• pitch : componente del passo della rotazione.
• yaw : componente di yaw della rotazione.
• roll: componente roll della rotazione.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration

Descrive la configurazione di un giunto su una mano simulata.

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

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.Position

Posizione dell'articolazione.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.Rotation

Rotazione dell'articolazione.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.TrackingAccuracy

Accuratezza del tracciamento dell'articolazione.

Microsoft.PerceptionSimulation.Frustum

Descrive un frustum di visualizzazione, come in genere usato da una fotocamera.

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

Microsoft.PerceptionSimulation.Frustum.Near

Distanza minima contenuta nel frustum.

Microsoft.PerceptionSimulation.Frustum.Far

Distanza massima contenuta nel frustum.

Microsoft.PerceptionSimulation.Frustum.FieldOfView

Campo orizzontale di visualizzazione del frustum, in radianti (minore di PI).

Microsoft.PerceptionSimulation.Frustum.AspectRatio

Rapporto tra il campo orizzontale della visualizzazione e il campo verticale della visualizzazione.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration

Descrive la configurazione dello schermo del visore VR simulato.

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

Trasformazione dal centro della testa all'occhio sinistro per scopi di rendering stereo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.LeftEyeRotation

Rotazione dell'occhio sinistro ai fini del rendering stereo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyePosition

Trasformazione dal centro della testa all'occhio destro per scopi di rendering stereo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyeRotation

Rotazione dell'occhio destro ai fini del rendering stereo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.Ipd

Valore Ipd segnalato dal sistema ai fini del rendering stereo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyEyeTransforms

Indica se i valori specificati per le trasformazioni dell'occhio sinistro e destro devono essere considerati validi e applicati al sistema in esecuzione.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyIpd

Indica se il valore specificato per Ipd deve essere considerato valido e applicato al sistema in esecuzione.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager

Radice per la generazione dei pacchetti usati per controllare un dispositivo.

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

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Device

Recuperare l'oggetto dispositivo simulato che interpreta l'uomo simulato e il mondo simulato.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Human

Recuperare l'oggetto che controlla l'essere umano simulato.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Reset

Reimposta lo stato predefinito della simulazione.

Microsoft.PerceptionSimulation.ISimulatedDevice

Interfaccia che descrive il dispositivo, che interpreta il mondo simulato e l'uomo simulato

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

Microsoft.PerceptionSimulation.ISimulatedDevice.HeadTracker

Recuperare il tracker head dal dispositivo simulato.

Microsoft.PerceptionSimulation.ISimulatedDevice.HandTracker

Recuperare lo strumento di rilevamento della mano dal dispositivo simulato.

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

Impostare le proprietà del dispositivo simulato in modo che corrispondano al tipo di dispositivo specificato.

Parametri

• type : nuovo tipo di dispositivo simulato

Microsoft.PerceptionSimulation.ISimulatedDevice2

Sono disponibili proprietà aggiuntive eseguendo il cast di ISimulatedDevice in ISimulatedDevice2

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

};

Microsoft.PerceptionSimulation.ISimulatedDevice2.IsUserPresent

Recupera o imposta se l'uomo simulato indossa attivamente l'auricolare.

Microsoft.PerceptionSimulation.ISimulatedDevice2.DisplayConfiguration

Recuperare o impostare le proprietà della visualizzazione simulata.

Microsoft.PerceptionSimulation.ISimulatedHeadTracker

Interfaccia che descrive la parte del dispositivo simulato che tiene traccia della testa dell'essere umano simulato.

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

Microsoft.PerceptionSimulation.ISimulatedHeadTracker.HeadTrackerMode

Recupera e imposta la modalità di rilevamento head corrente.

Microsoft.PerceptionSimulation.ISimulatedHandTracker

Interfaccia che descrive la parte del dispositivo simulato che tiene traccia delle mani dell'uomo simulato

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

Recuperare la posizione del nodo rispetto al mondo, espressa in metri.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Position

Recuperare e impostare la posizione del tracciatore della mano simulata, rispetto al centro della testa.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Pitch

Recuperare e impostare l'inclinazione verso il basso dell'indicatore di mano simulato.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.FrustumIgnored

Recuperare e impostare se il frustum del tracker della mano simulata viene ignorato. Quando vengono ignorate, entrambe le mani sono sempre visibili. Quando le mani non vengono ignorate (impostazione predefinita) sono visibili solo quando si trovano all'interno del frustum del tracciatore della mano.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Frustum

Recuperare e impostare le proprietà frustum usate per determinare se le mani sono visibili al tracker della mano simulato.

Microsoft.PerceptionSimulation.ISimulatedHuman

Interfaccia di primo livello per controllare l'essere umano simulato.

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

Recuperare e impostare la posizione del nodo in relazione al mondo, in metri. La posizione corrisponde a un punto al centro dei piedi dell'uomo.

Microsoft.PerceptionSimulation.ISimulatedHuman.Direction

Recuperare e impostare la direzione dei volti umani simulati nel mondo. 0 radianti si affacciano sull'asse Z negativo. I radianti positivi ruotano in senso orario sull'asse Y.

Microsoft.PerceptionSimulation.ISimulatedHuman.Height

Recuperare e impostare l'altezza dell'uomo simulato, in metri.

Microsoft.PerceptionSimulation.ISimulatedHuman.LeftHand

Recuperare la mano sinistra dell'essere umano simulato.

Microsoft.PerceptionSimulation.ISimulatedHuman.RightHand

Recuperare la mano destra dell'essere umano simulato.

Microsoft.PerceptionSimulation.ISimulatedHuman.Head

Recuperare la testa dell'essere umano simulato.

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

Spostare l'essere umano simulato rispetto alla posizione corrente, in metri.

Parametri

• translation: traduzione da spostare, rispetto alla posizione corrente.

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

Ruotare l'uomo simulato rispetto alla direzione corrente, in senso orario sull'asse Y

Parametri

• radianti - Quantità di rotazione intorno all'asse Y.

Microsoft.PerceptionSimulation.ISimulatedHuman2

Sono disponibili proprietà aggiuntive eseguendo il cast di ISimulatedHuman a ISimulatedHuman2

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

Microsoft.PerceptionSimulation.ISimulatedHuman2.LeftController

Recuperare il controller DOF a sinistra.

Microsoft.PerceptionSimulation.ISimulatedHuman2.RightController

Recuperare il controller 6-DOF corretto.

Microsoft.PerceptionSimulation.ISimulatedHand

Interfaccia che descrive una mano dell'uomo simulato

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

Recuperare la posizione del nodo rispetto al mondo, espressa in metri.

Microsoft.PerceptionSimulation.ISimulatedHand.Position

Recuperare e impostare la posizione della mano simulata rispetto all'uomo, in metri.

Microsoft.PerceptionSimulation.ISimulatedHand.Activated

Recuperare e impostare se la mano è attualmente attivata.

Microsoft.PerceptionSimulation.ISimulatedHand.Visible

Recupera se la mano è attualmente visibile al SimulatedDevice, ovvero se è in una posizione da rilevare da HandTracker.

Microsoft.PerceptionSimulation.ISimulatedHand.EnsureVisible

Spostare la mano in modo che sia visibile a SimulatedDevice.

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

Spostare la posizione della mano simulata rispetto alla posizione corrente, in metri.

Parametri

• translation: quantità di traduzione della mano simulata.

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

Eseguire un gesto usando la mano simulata. Verrà rilevato dal sistema solo se la mano è abilitata.

Parametri

• movimento: movimento da eseguire.

Microsoft.PerceptionSimulation.ISimulatedHand2

Sono disponibili proprietà aggiuntive eseguendo il cast di un oggetto ISimulatedHand a ISimulatedHand2.

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

Microsoft.PerceptionSimulation.ISimulatedHand2.Orientation

Recuperare o impostare la rotazione della mano simulata. I radianti positivi ruotano in senso orario quando si guarda lungo l'asse.

Microsoft.PerceptionSimulation.ISimulatedHand3

Sono disponibili proprietà aggiuntive eseguendo il cast di un oggetto ISimulatedHand a 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

Ottenere la configurazione congiunta per il giunto specificato.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetJointConfiguration

Impostare la configurazione congiunta per il giunto specificato.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetHandPose

Impostare la mano su una posizione nota con un flag facoltativo da animare. Nota: l'animazione non comporterà immediatamente articolazioni che riflettono le configurazioni finali delle articolazioni.

Microsoft.PerceptionSimulation.ISimulatedHead

Interfaccia che descrive la testa dell'essere umano simulato.

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

Microsoft.PerceptionSimulation.ISimulatedHead.WorldPosition

Recuperare la posizione del nodo rispetto al mondo, espressa in metri.

Microsoft.PerceptionSimulation.ISimulatedHead.Rotation

Recuperare la rotazione della testa simulata. I radianti positivi ruotano in senso orario quando si guarda lungo l'asse.

Microsoft.PerceptionSimulation.ISimulatedHead.Diametro

Recuperare il diametro della testa simulata. Questo valore viene usato per determinare il centro della testa (punto di rotazione).

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

Ruotare la testa simulata rispetto alla rotazione corrente. I radianti positivi ruotano in senso orario quando si guarda lungo l'asse.

Parametri

• rotation - Quantità da ruotare.

Microsoft.PerceptionSimulation.ISimulatedHead2

Sono disponibili proprietà aggiuntive eseguendo il cast di un oggetto ISimulatedHead a ISimulatedHead2

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

Microsoft.PerceptionSimulation.ISimulatedHead2.Eyes

Recuperare gli occhi dell'uomo simulato.

Microsoft.PerceptionSimulation.ISimulatedSixDofController

Interfaccia che descrive un controller DOF associato all'essere umano simulato.

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

Recuperare la posizione del nodo rispetto al mondo, espressa in metri.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Status

Recuperare o impostare lo stato corrente del controller. Lo stato del controller deve essere impostato su un valore diverso da Disattivato prima che qualsiasi chiamata a spostare, ruotare o premere i pulsanti avrà esito positivo.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Position

Recuperare o impostare la posizione del controller simulato rispetto all'essere umano, in metri.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Orientation

Recuperare o impostare l'orientamento del controller simulato.

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

Spostare la posizione del controller simulato rispetto alla posizione corrente, in metri.

Parametri

• translation: quantità di conversione del controller simulato.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.PressButton(SimulatedSixDofControllerButton)

Premere un pulsante sul controller simulato. Verrà rilevato dal sistema solo se il controller è abilitato.

Parametri

• button : pulsante da premere.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.ReleaseButton(SimulatedSixDofControllerButton)

Rilasciare un pulsante nel controller simulato. Verrà rilevato dal sistema solo se il controller è abilitato.

Parametri

• button : pulsante da rilasciare.

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

Ottiene la posizione di un dito simulato sul touchpad del controller simulato.

Parametri

• x - Posizione orizzontale del dito.
• y - Posizione verticale del dito.

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

Impostare la posizione di un dito simulato sul touchpad del controller simulato.

Parametri

• x - Posizione orizzontale del dito.
• y - Posizione verticale del dito.

Microsoft.PerceptionSimulation.ISimulatedSixDofController2

Sono disponibili proprietà e metodi aggiuntivi eseguendo il cast di un oggetto ISimulatedSixDofController in 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)

Ottenere la posizione della levetta simulata nel controller simulato.

Parametri

• x - Posizione orizzontale della levetta.
• y : posizione verticale della levetta.

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

Impostare la posizione della levetta simulata sul controller simulato.

Parametri

• x - Posizione orizzontale della levetta.
• y : posizione verticale della levetta.

Microsoft.PerceptionSimulation.ISimulatedSixDofController2.BatteryLevel

Recuperare o impostare il livello della batteria del controller simulato. Il valore deve essere maggiore di 0,0 e minore o uguale a 100,0.

Microsoft.PerceptionSimulation.ISimulatedEyes

Interfaccia che descrive gli occhi dell'uomo simulato.

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

Microsoft.PerceptionSimulation.ISimulatedEyes.Rotation

Recuperare la rotazione degli occhi simulati. I radianti positivi ruotano in senso orario quando si guarda lungo l'asse.

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

Ruotare gli occhi simulati rispetto alla rotazione corrente. I radianti positivi ruotano in senso orario quando si guarda lungo l'asse.

Parametri

• rotation - Quantità da ruotare.

Microsoft.PerceptionSimulation.ISimulatedEyes.CalibrationState

Recupera o imposta lo stato di calibrazione degli occhi simulati.

Microsoft.PerceptionSimulation.ISimulatedEyes.WorldPosition

Recuperare la posizione del nodo rispetto al mondo, espressa in metri.

Microsoft.PerceptionSimulation.ISimulationRecording

Interfaccia per interagire con una singola registrazione caricata per la riproduzione.

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

Microsoft.PerceptionSimulation.ISimulationRecording.DataTypes

Recupera l'elenco dei tipi di dati nella registrazione.

Microsoft.PerceptionSimulation.ISimulationRecording.State

Recupera lo stato corrente della registrazione.

Microsoft.PerceptionSimulation.ISimulationRecording.Play

Avviare la riproduzione. Se la registrazione è sospesa, la riproduzione riprenderà dalla posizione sospesa; se arrestata, la riproduzione inizierà all'inizio. Se è già in riproduzione, questa chiamata viene ignorata.

Microsoft.PerceptionSimulation.ISimulationRecording.Pause

Sospende la riproduzione nella posizione corrente. Se la registrazione viene arrestata, la chiamata viene ignorata.

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

Cerca la registrazione nell'ora specificata (in intervalli di 100 nanosecondi dall'inizio) e si sospende in tale posizione. Se l'ora supera la fine della registrazione, viene sospesa all'ultimo fotogramma.

Parametri

• ticks - Il tempo a cui cercare.

Microsoft.PerceptionSimulation.ISimulationRecording.Stop

Arresta la riproduzione e reimposta la posizione all'inizio.

Microsoft.PerceptionSimulation.ISimulationRecordingCallback

Interfaccia per la ricezione delle modifiche dello stato durante la riproduzione.

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

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

Chiamato quando lo stato di riproduzione di ISimulationRecording è cambiato.

Parametri

• newState: nuovo stato della registrazione.

Microsoft.PerceptionSimulation.PerceptionSimulationManager

Oggetto radice per la creazione di oggetti Perception Simulation.

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)

Creare sull'oggetto per generare pacchetti simulati e recapitarli al sink fornito.

Parametri

• sink: sink che riceverà tutti i pacchetti generati.

Valore restituito

Gestore creato.

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

Creare un sink, che archivia tutti i pacchetti ricevuti in un file nel percorso specificato.

Parametri

• path: percorso del file da creare.

Valore restituito

Sink creato.

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

Caricare una registrazione dal file specificato.

Parametri

• path: percorso del file da caricare.
• factory: factory usata dalla registrazione per la creazione di un ISimulationStreamSink quando necessario.

Valore restituito

Registrazione caricata.

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

Caricare una registrazione dal file specificato.

Parametri

• path: percorso del file da caricare.
• factory: factory usata dalla registrazione per la creazione di un ISimulationStreamSink quando necessario.
• callback: callback che riceve aggiornamenti che regradino lo stato della registrazione.

Valore restituito

Registrazione caricata.

Microsoft.PerceptionSimulation.StreamDataTypes

Descrive i diversi tipi di dati di flusso.

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

Valore sentinel usato per indicare nessun tipo di dati di flusso.

Microsoft.PerceptionSimulation.StreamDataTypes.Head

Flusso di dati per la posizione e l'orientamento della testa.

Microsoft.PerceptionSimulation.StreamDataTypes.Hands

Flusso di dati per la posizione e i movimenti delle mani.

Microsoft.PerceptionSimulation.StreamDataTypes.SpatialMapping

Flusso di dati per il mapping spaziale dell'ambiente.

Microsoft.PerceptionSimulation.StreamDataTypes.Calibration

Flusso di dati per la calibrazione del dispositivo. I pacchetti di calibrazione vengono accettati solo da un sistema in modalità remota.

Microsoft.PerceptionSimulation.StreamDataTypes.Environment

Flusso di dati per l'ambiente del dispositivo.

Microsoft.PerceptionSimulation.StreamDataTypes.SixDofControllers

Flusso di dati per i controller del movimento.

Microsoft.PerceptionSimulation.StreamDataTypes.Eyes

Flusso di dati con gli occhi dell'uomo simulato.

Microsoft.PerceptionSimulation.StreamDataTypes.DisplayConfiguration

Flusso di dati con la configurazione di visualizzazione del dispositivo.

Microsoft.PerceptionSimulation.StreamDataTypes.All

Valore sentinel usato per indicare tutti i tipi di dati registrati.

Microsoft.PerceptionSimulation.ISimulationStreamSink

Oggetto che riceve pacchetti di dati da un flusso di simulazione.

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

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

Riceve un singolo pacchetto, digitato internamente e con controllo delle versioni.

Parametri

• length : lunghezza del pacchetto.
• packet : dati del pacchetto.

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory

Oggetto che crea ISimulationStreamSink.

public interface ISimulationStreamSinkFactory
{
    ISimulationStreamSink CreateSimulationStreamSink();
}

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory.CreateSimulationStreamSink()

Crea una singola istanza di ISimulationStreamSink.

Valore restituito

Sink creato.