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 eseseguono 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 poter automatizzare i test. Ad esempio, è possibile simulare l'input di un essere umano che cerca in 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 usate 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 Perception Simulation.

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 di HoloLens 2, funzionano anche per Windows Mixed Reality 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 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 durante la compilazione. Si trova nella finestra delle proprietà per il file binario.
   

5. Impostare la piattaforma della soluzione attiva su x64. Usare il 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, si emetteranno 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 Device Portal sulla barra degli strumenti

di dispositivi Aprire Portale di dispositivi: aprire Il portale di dispositivi di Windows per il sistema operativo HoloLens nell'emulatore. Per Windows Mixed Reality, questo valore può essere recuperato nell'app Impostazioni in "Aggiorna sicurezza &", 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 : 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 a Windows Device Portal nel dispositivo o nell'emulatore di destinazione. Se ci si connette all'emulatore tramite il relativo 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 proprietà su true per gli scenari di test, che consentono al test di assumere il controllo. L'emulatore e la simulazione Windows Mixed Reality 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, creerai 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 6-DOF

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), i controller 6-DOF simulati possono essere installati e attivati 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 verificare 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à head tracker

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

Microsoft.PerceptionSimulation.HeadTrackerMode.Default

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

Microsoft.PerceptionSimulation.HeadTrackerMode.Orientation

Orientamento solo tracciamento della 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 della 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 dal dito.

Microsoft.PerceptionSimulation.SimulatedGesture.Home

Movimento home/system.

Microsoft.PerceptionSimulation.SimulatedGesture.Max

Movimento massimo valido.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus

I possibili stati 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 è 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 utilizzato 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. Si tratta del valore predefinito.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Configuring

Gli occhi vengono calibrati.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.UserCalibrationNeeded

Gli occhi devono essere calibrati.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy

Precisione del tracciamento di un giunto della mano.

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

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Unavailable

L'articolazione non è tracciata.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Approximate

La posizione comune viene dedotta.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Visible

Il giunto è completamente tracciato.

Microsoft.PerceptionSimulation.SimulatedHandPose

Precisione 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)Microsoft.PerceptionSimulation.Vector3.#ctor(System.Single,System.Single)

Costruire 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 Pitch della rotazione, intorno all'asse X.

Microsoft.PerceptionSimulation.Rotation3.Yaw

Componente Yaw della rotazione, intorno all'asse Y.

Microsoft.PerceptionSimulation.Rotation3.Roll

Componente Roll della rotazione, intorno all'asse Z.

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

Costruire una nuova rotazione3.

Parametri

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

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration

Descrive la configurazione di un'associazione su una mano simulata.

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

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.Position

Posizione del comune.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.Rotation

Rotazione dell'articolazione.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.TrackingAccuracy

Accuratezza del rilevamento 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 della vista del frustum, in radianti (minore di PI).

Microsoft.PerceptionSimulation.Frustum.AspectRatio

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

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration

Descrive la configurazione del display del visore 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

La trasformazione dal centro della testa all'occhio sinistro a scopo di rendering stereo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.LeftEyeRotation

Rotazione dell'occhio sinistro ai fini del rendering stereo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyePosition

La trasformazione dal centro della testa all'occhio destro a scopo di rendering stereo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyeRotation

Rotazione dell'occhio destro a scopo di rendering stereo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.Ipd

Valore Ipd segnalato dal sistema a scopo di rendering stereo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyEyeTransforms

Se i valori forniti per le trasformazioni degli occhi sinistro e destro devono essere considerati validi e applicati al sistema in esecuzione.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyIpd

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'uomo 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 il localizzatore di mano dal dispositivo simulato.

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

Impostare le proprietà del dispositivo simulato per corrispondere al tipo di dispositivo specificato.

Parametri

• type - Nuovo tipo di dispositivo simulato

Microsoft.PerceptionSimulation.ISimulatedDevice2

Le proprietà aggiuntive sono disponibili 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

Recuperare o impostare se l'uomo simulato indossa attivamente il visore.

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'uomo 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 con relazione al mondo, in metri.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Position

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

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Pitch

Recuperare e impostare il passo verso il basso del localizzatore di mano simulato.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.FrustumIgnored

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

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Frustum

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

Microsoft.PerceptionSimulation.ISimulatedHuman

Interfaccia di primo livello per controllare l'uomo 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 con 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 trova verso il basso l'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'uomo simulato.

Microsoft.PerceptionSimulation.ISimulatedHuman.RightHand

Recuperare la mano destra dell'uomo simulato.

Microsoft.PerceptionSimulation.ISimulatedHuman.Head

Recuperare la testa dell'uomo simulato.

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

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

Parametri

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

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

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

Parametri

• radianti: quantità di rotazione attorno 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 in relazione 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 in cui essere rilevata 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 traslazione 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 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 l'articolazione specificata.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetJointConfiguration

Impostare la configurazione congiunta per l'articolazione specificata.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetHandPose

Impostare la mano su una posa nota con un flag facoltativo da animare. Nota: l'animazione non comporterà articolazioni che riflettono immediatamente le loro configurazioni di articolazione finale.

Microsoft.PerceptionSimulation.ISimulatedHead

Interfaccia che descrive la testa dell'uomo 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 in relazione 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.Diameter

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 in relazione 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 Off prima che qualsiasi chiamata a spostare, ruotare o premere pulsanti avrà esito positivo.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Position

Recuperare o impostare la posizione del controller simulato rispetto all'oggetto 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 altre proprietà e metodi 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 del pollice simulato sul controller simulato.

Parametri

• x - Posizione orizzontale del pollice.
• y : posizione verticale del pollice.

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

Impostare la posizione del pollice simulato sul controller simulato.

Parametri

• x - Posizione orizzontale del pollice.
• y : posizione verticale del pollice.

Microsoft.PerceptionSimulation.ISimulatedSixDofController2.BatteryLevel

Recuperare o impostare il livello di 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

• rotazione: importo 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 con relazione al mondo, in metri.

Microsoft.PerceptionSimulation.ISimulationRecording

Interfaccia per l'interazione 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 viene sospesa, la riproduzione riprenderà dalla posizione sospesa; se arrestata, la riproduzione inizierà all'inizio. Se si esegue già la 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 all'ora specificata (in intervalli di 100 nanosecondi dall'inizio) e sospende in tale posizione. Se il tempo supera la fine della registrazione, viene sospeso 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 Simulazione percezione.

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

Gestione creata.

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 : una factory usata dalla registrazione per la creazione di un oggetto 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 : una factory usata dalla registrazione per la creazione di un oggetto ISimulationStreamSink quando necessario.
• callback: callback, che riceve aggiornamenti rigradando 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 di 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(lunghezza uint, byte[] pacchetti)

Riceve un singolo pacchetto, digitato internamente e con versioni.

Parametri

• lunghezza: lunghezza del pacchetto.
• pacchetto : i dati del pacchetto.

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory

Oggetto che crea ISimulationStreamSink.

public interface ISimulationStreamSinkFactory
{
    ISimulationStreamSink CreateSimulationStreamSink();
}

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory.CreateSimulationStreamSink()

Crea un'unica istanza di ISimulationStreamSink.

Valore restituito

Sink creato.