Simulação de perceção

  • Artigo

Pretende criar um teste automatizado para a sua aplicação? Pretende que os testes ultrapassem os testes de unidades ao nível do componente e exerçam realmente a sua aplicação ponto a ponto? A Simulação de Perceção é o que procura. A biblioteca de Simulação de Percepção envia dados de entrada humanos e mundiais para a sua aplicação para que possa automatizar os seus testes. Por exemplo, pode simular a entrada de um humano que procura uma posição específica e repetível e, em seguida, utilizar um gesto ou comando de movimento.

A Simulação de Percepção pode enviar entradas simuladas como esta para um HoloLens físico, o emulador do HoloLens (primeira geração), o Emulador HoloLens 2 ou um PC com o Portal do Mixed Reality instalado. A Simulação de Perceção ignora os sensores dinâmicos num dispositivo Mixed Reality e envia entradas simuladas para aplicações em execução no dispositivo. As aplicações recebem estes eventos de entrada através das mesmas APIs que utilizam sempre e não conseguem distinguir entre a execução com sensores reais e a Simulação de Perceção. A Simulação de Percepção é a mesma tecnologia utilizada pelos emuladores do HoloLens para enviar entradas simuladas para a Máquina Virtual do HoloLens.

Para começar a utilizar a simulação no código, comece por criar um objeto IPerceptionSimulationManager. A partir desse objeto, pode emitir comandos para controlar as propriedades de um "humano" simulado, incluindo posição da cabeça, posição da mão e gestos. Também pode ativar e manipular controladores de movimento.

Configurar um Projeto do Visual Studio para Simulação de Perceção

  1. Instale o emulador do HoloLens no seu PC de desenvolvimento. O emulador inclui as bibliotecas que utiliza para a Simulação de Perceção.

  2. Crie um novo projeto de ambiente de trabalho C# do Visual Studio (um Projeto de Consola funciona perfeitamente para começar).

  3. Adicione os seguintes binários ao projeto como referências (Project-Add-Reference>>...). Pode encontrá-los em %ProgramFiles(x86)%\Microsoft XDE\(version), como %ProgramFiles(x86)%\Microsoft XDE\10.0.18362.0 para o Emulador do HoloLens 2.

    Nota

    Embora os binários façam parte da HoloLens 2 Emulador, também funcionam para Windows Mixed Reality no ambiente de trabalho.)

    a. PerceptionSimulationManager.Interop.dll - Wrapper C# gerido para Simulação de Perceção.
    b. PerceptionSimulationRest.dll - Biblioteca para configurar um canal de comunicação de socket Web para o HoloLens ou emulador.
    c. SimulationStream.Interop.dll - Tipos partilhados para simulação.

  4. Adicionar o PerceptionSimulationManager.dll binário de implementação ao projeto

    a. Primeiro, adicione-o como binário ao projeto (Project-Add-Existing>> Item...). Guarde-o como uma ligação para que não o copie para a pasta de origem do projeto.
    Adicionar PerceptionSimulationManager.dll ao projeto como uma ligação

    b. Em seguida, certifique-se de que é copiado para a pasta de saída na compilação. Isto está na folha de propriedades do binário.
    Marcar PerceptionSimulationManager.dll para copiar para o diretório de saída

  5. Defina a plataforma de soluções ativa como x64. (Utilize o Configuration Manager para criar uma Entrada de plataforma para x64, se ainda não existir uma.)

Criar um Objeto IPerceptionSimulation Manager

Para controlar a simulação, irá emitir atualizações para objetos obtidos a partir de um objeto IPerceptionSimulationManager. O primeiro passo é obter esse objeto e ligá-lo ao seu dispositivo de destino ou emulador. Pode obter o endereço IP do seu emulador ao clicar no botão Portal do Dispositivo na barra de ferramentas

Ícone Abrir Portal do Dispositivo: abra o Portal do Dispositivo: abra o Portal do Dispositivo Windows para o SO HoloLens no emulador. Por Windows Mixed Reality, isto pode ser obtido na aplicação Definições em "Atualizar & Segurança" e, em seguida, "Para programadores" na secção "Ligar com:" em "Ativar Portal do Dispositivo". Certifique-se de que anota o endereço IP e a porta.

Primeiro, irá chamar RestSimulationStreamSink.Create para obter um objeto RestSimulationStreamSink. Este é o dispositivo de destino ou emulador que irá controlar sobre uma ligação http. Os comandos serão transmitidos e processados pelo Portal do Dispositivo Windows em execução no dispositivo ou emulador. Os quatro parâmetros necessários para criar um objeto são:

  • URI URI – endereço IP do dispositivo de destino (por exemplo, "https://123.123.123.123" ou "https://123.123.123.123:50080")
  • Credenciais System.Net.NetworkCredential – Nome de utilizador/palavra-passe para ligar ao Portal do Dispositivo Windows no dispositivo de destino ou emulador. Se estiver a ligar ao emulador através do respetivo endereço local (por exemplo, 168.. *) no mesmo PC, todas as credenciais serão aceites.
  • bool normal - Verdadeiro para prioridade normal, falso para baixa prioridade. Geralmente, quer definir isto como verdadeiro para cenários de teste, o que permite que o teste assuma o controlo. O emulador e a simulação de Windows Mixed Reality utilizam ligações de baixa prioridade. Se o teste também utilizar uma ligação de baixa prioridade, a ligação estabelecida mais recentemente estará no controlo.
  • Token System.Threading.CancellationToken - Token para cancelar a operação assíncrona.

Em segundo lugar, irá criar o IPerceptionSimulationManager. Este é o objeto que utiliza para controlar a simulação. Isto também tem de ser feito num método assíncrono.

Controlar o Humano simulado

Um IPerceptionSimulationManager tem uma propriedade Humana que devolve um objeto ISimulatedHuman. Para controlar o humano simulado, execute operações neste objeto. Por exemplo:

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

Aplicação de consola C# de Exemplo Básico

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

Aplicação de consola C# de Exemplo Alargado

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 nos controladores 6 DOF

Antes de chamar quaisquer propriedades nos métodos num controlador 6 DOF simulado, tem de ativar o controlador. Não fazê-lo resultará numa exceção. A partir do Atualização de Maio de 2019 do Windows 10, os controladores 6 DOF simulados podem ser instalados e ativados ao definir a propriedade Estado no objeto ISimulatedSixDofController como SimulatedSixDofControllerStatus.Active. Na Atualização de Outubro de 2018 do Windows 10 e anterior, primeiro tem de instalar separadamente um controlador 6 DOF simulado ao chamar a ferramenta PerceptionSimulationDevice localizada na pasta \Windows\System32. A utilização desta ferramenta é a seguinte:

    PerceptionSimulationDevice.exe <action> 6dof <instance>

Por exemplo

    PerceptionSimulationDevice.exe i 6dof 1

As ações suportadas são:

  • i = instalar
  • q = consulta
  • r = remover

As instâncias suportadas são:

  • 1 = o controlador 6 DOF esquerdo
  • 2 = o controlador de 6 DOF à direita

O código de saída do processo indicará êxito (valor de retorno zero) ou falha (um valor devolvido diferente de zero). Ao utilizar a ação "q" para consultar se um controlador está instalado, o valor devolvido será zero (0) se o controlador ainda não estiver instalado ou um (1) se o controlador estiver instalado.

Ao remover um controlador na Atualização de Outubro de 2018 do Windows 10 ou anterior, defina primeiro o estado como Desativado através da API e, em seguida, chame a ferramenta PerceptionSimulationDevice.

Esta ferramenta tem de ser executada como Administrador.

Referência de API

Microsoft.PerceptionSimulation.SimulatedDeviceType

Descreve um tipo de dispositivo simulado

public enum SimulatedDeviceType
{
    Reference = 0
}

Microsoft.PerceptionSimulation.SimulatedDeviceType.Reference

Um dispositivo de referência fictício, a predefinição para PerceptionSimulationManager

Microsoft.PerceptionSimulation.HeadTrackerMode

Descreve um modo de controlador principal

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

Microsoft.PerceptionSimulation.HeadTrackerMode.Default

Controlo de Cabeças Predefinido. Isto significa que o sistema pode selecionar o melhor modo de controlo de cabeças com base nas condições de runtime.

Microsoft.PerceptionSimulation.HeadTrackerMode.Orientation

Orientação Apenas Controlo de Cabeças. Isto significa que a posição controlada pode não ser fiável e algumas funcionalidades dependentes da posição de cabeça podem não estar disponíveis.

Microsoft.PerceptionSimulation.HeadTrackerMode.Position

Controlo de Cabeças Posicionais. Isto significa que a posição e a orientação da cabeça controladas são fiáveis

Microsoft.PerceptionSimulation.SimulatedGesture

Descreve um gesto simulado

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

Microsoft.PerceptionSimulation.SimulatedGesture.None

Um valor sentinel utilizado para indicar que não existem gestos.

Microsoft.PerceptionSimulation.SimulatedGesture.FingerPressed

Um gesto premido com o dedo.

Microsoft.PerceptionSimulation.SimulatedGesture.FingerReleased

Um gesto de dedo libertado.

Microsoft.PerceptionSimulation.SimulatedGesture.Home

O gesto home/system.

Microsoft.PerceptionSimulation.SimulatedGesture.Max

O gesto máximo válido.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus

Os estados possíveis de um controlador 6 DOF simulado.

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

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Off

O controlador 6 DOF está desativado.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Active

O controlador 6 DOF está ativado e controlado.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.TrackingLost

O controlador 6 DOF está ativado, mas não pode ser controlado.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton

Os botões suportados num controlador 6 DOF simulado.

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

Um valor sentinel utilizado para indicar que não existem botões.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Home

O botão Base é premido.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Menu

O botão Menu é premido.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Grip

O botão Detenção é premido.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.TouchpadPress

O TouchPad é premido.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Select

O botão Selecionar é premido.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.TouchpadTouch

O TouchPad é tocado.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Thumbstick

O Manípulo é premido.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Max

O botão máximo válido.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState

O estado de calibragem dos olhos simulados

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

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Unavailable

A calibragem dos olhos não está disponível.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Ready

Os olhos foram calibrados. Este é o valor predefinido.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Configuring

Os olhos estão a ser calibrados.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.UserCalibrationNeeded

Os olhos precisam de ser calibrados.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy

A precisão de controlo de uma articulação da mão.

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

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Unavailable

A articulação não é controlada.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Approximate

A posição conjunta é inferida.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Visible

A articulação é totalmente controlada.

Microsoft.PerceptionSimulation.SimulatedHandPose

A precisão de controlo de uma articulação da mão.

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

Microsoft.PerceptionSimulation.SimulatedHandPose.Closed

As articulações dos dedos da mão estão configuradas para refletir uma pose fechada.

Microsoft.PerceptionSimulation.SimulatedHandPose.Open

As juntas dos dedos da mão estão configuradas para refletir uma pose aberta.

Microsoft.PerceptionSimulation.SimulatedHandPose.Point

As juntas dos dedos da mão estão configuradas para refletir uma pose apontadora.

Microsoft.PerceptionSimulation.SimulatedHandPose.Pinch

As articulações dos dedos da mão estão configuradas para refletir uma pose de aproximar os dedos.

Microsoft.PerceptionSimulation.SimulatedHandPose.Max

O valor máximo válido para SimulatedHandPose.

Microsoft.PerceptionSimulation.PlaybackState

Descreve o estado de uma reprodução.

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

Microsoft.PerceptionSimulation.PlaybackState.Stopped

A gravação está atualmente parada e pronta para reprodução.

Microsoft.PerceptionSimulation.PlaybackState.Playing

A gravação está a ser reproduzida.

Microsoft.PerceptionSimulation.PlaybackState.Paused

A gravação está atualmente em pausa.

Microsoft.PerceptionSimulation.PlaybackState.End

A gravação chegou ao fim.

Microsoft.PerceptionSimulation.Vector3

Descreve um vetor de três componentes, que pode descrever um ponto ou um vetor no espaço 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

O componente X do vetor.

Microsoft.PerceptionSimulation.Vector3.Y

O componente Y do vetor.

Microsoft.PerceptionSimulation.Vector3.Z

O componente Z do vetor.

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

Construa um novo Vector3.

Parâmetros

  • x – o componente x do vetor.
  • y - O componente y do vetor.
  • z - O componente z do vetor.

Microsoft.PerceptionSimulation.Rotation3

Descreve uma rotação de três componentes.

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

Microsoft.PerceptionSimulation.Rotation3.Pitch

O componente Pitch da Rotação, em torno do eixo X.

Microsoft.PerceptionSimulation.Rotation3.Yaw

O componente Yaw da Rotação, em torno do eixo Y.

Microsoft.PerceptionSimulation.Rotation3.Roll

O componente Roll da Rotação, mesmo à volta do eixo Z.

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

Construa uma nova Rotação3.

Parâmetros

  • pitch – o componente de tom da Rotação.
  • yaw – o componente yaw da Rotação.
  • roll - O componente roll da Rotação.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration

Descreve a configuração de uma junta numa mão simulada.

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

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.Position

A posição da junta.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.Rotation

A rotação da junta.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.TrackingAccuracy

A precisão de controlo da articulação.

Microsoft.PerceptionSimulation.Frustum

Descreve uma vista frustum, normalmente utilizada por uma câmara.

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

Microsoft.PerceptionSimulation.Frustum.Near

A distância mínima contida no frusto.

Microsoft.PerceptionSimulation.Frustum.Far

A distância máxima contida no frusto.

Microsoft.PerceptionSimulation.Frustum.FieldOfView

O campo horizontal de vista da frustum, em radianos (menos que PI).

Microsoft.PerceptionSimulation.Frustum.AspectRatio

A proporção entre o campo de vista horizontal e o campo de vista vertical.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration

Descreve a configuração do ecrã do headset simulado.

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

A transformação do centro da cabeça para o olho esquerdo para fins de composição estéreo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.LeftEyeRotation

A rotação do olho esquerdo para fins de composição estéreo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyePosition

A transformação do centro da cabeça para o olho direito para fins de composição estéreo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyeRotation

A rotação do olho direito para fins de composição estéreo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.Ipd

O valor ipd comunicado pelo sistema para fins de composição estéreo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyEyeTransforms

Se os valores fornecidos para transformações do olho esquerdo e direito devem ser considerados válidos e aplicados ao sistema em execução.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyIpd

Se o valor fornecido para Ipd deve ser considerado válido e aplicado ao sistema em execução.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager

Raiz para gerar os pacotes utilizados para controlar um dispositivo.

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

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Device

Obtenha o objeto de dispositivo simulado que interpreta o humano simulado e o mundo simulado.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Human

Obtenha o objeto que controla o humano simulado.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Reset

Repõe a simulação para o estado predefinido.

Microsoft.PerceptionSimulation.ISimulatedDevice

Interface que descreve o dispositivo, que interpreta o mundo simulado e o humano simulado

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

Microsoft.PerceptionSimulation.ISimulatedDevice.HeadTracker

Obtenha o Controlador Principal a partir do Dispositivo Simulado.

Microsoft.PerceptionSimulation.ISimulatedDevice.HandTracker

Obtenha o Controlador manual a partir do Dispositivo Simulado.

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

Defina as propriedades do dispositivo simulado para corresponder ao tipo de dispositivo fornecido.

Parâmetros

  • type - O novo tipo de Dispositivo Simulado

Microsoft.PerceptionSimulation.ISimulatedDevice2

Estão disponíveis propriedades adicionais ao lançar o ISimulatedDevice para ISimulatedDevice2

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

};

Microsoft.PerceptionSimulation.ISimulatedDevice2.IsUserPresent

Obtenha ou defina se o humano simulado está ou não a utilizar ativamente o headset.

Microsoft.PerceptionSimulation.ISimulatedDevice2.DisplayConfiguration

Obtenha ou defina as propriedades do ecrã simulado.

Microsoft.PerceptionSimulation.ISimulatedHeadTracker

Interface que descreve a parte do dispositivo simulado que controla a cabeça do humano simulado.

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

Microsoft.PerceptionSimulation.ISimulatedHeadTracker.HeadTrackerMode

Obtém e define o modo de controlador principal atual.

Microsoft.PerceptionSimulation.ISimulatedHandTracker

Interface que descreve a parte do dispositivo simulado que controla as mãos do humano simulado

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

Obtenha a posição do nó com relação ao mundo, em metros.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Position

Obtenha e defina a posição do controlador de mão simulado, em relação ao centro da cabeça.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Pitch

Obtenha e defina o tom descendente do controlador de mão simulado.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.FrustumIgnored

Obtenha e defina se o frustum do controlador de mão simulado é ignorado. Quando ignoradas, ambas as mãos são sempre visíveis. Quando não são ignoradas (a predefinição) as mãos só são visíveis quando estão dentro do frustum do controlador de mãos.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Frustum

Obtenha e defina as propriedades frustum utilizadas para determinar se as mãos estão visíveis para o controlador manual simulado.

Microsoft.PerceptionSimulation.ISimulatedHuman

Interface de nível superior para controlar o humano simulado.

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

Obtenha e defina a posição do nó com relação ao mundo, em metros. A posição corresponde a um ponto no centro dos pés do humano.

Microsoft.PerceptionSimulation.ISimulatedHuman.Direction

Obtenha e defina a direção dos rostos humanos simulados no mundo. 0 radianos virados para baixo no eixo Z negativo. Os radianos positivos rodam no sentido dos ponteiros do relógio sobre o eixo Y.

Microsoft.PerceptionSimulation.ISimulatedHuman.Height

Obtenha e defina a altura do humano simulado, em metros.

Microsoft.PerceptionSimulation.ISimulatedHuman.LeftHand

Obtenha a mão esquerda do humano simulado.

Microsoft.PerceptionSimulation.ISimulatedHuman.RightHand

Obtenha a mão direita do humano simulado.

Microsoft.PerceptionSimulation.ISimulatedHuman.Head

Obtenha a cabeça do humano simulado.

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

Mova o humano simulado relativamente à sua posição atual, em metros.

Parâmetros

  • tradução – a tradução a mover, relativamente à posição atual.

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

Rodar o humano simulado relativamente à sua direção atual, no sentido dos ponteiros do relógio sobre o eixo Y

Parâmetros

  • radianos – a quantidade a rodar em torno do eixo Y.

Microsoft.PerceptionSimulation.ISimulatedHuman2

Estão disponíveis propriedades adicionais ao lançar o ISimulatedHuman para ISimulatedHuman2

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

Microsoft.PerceptionSimulation.ISimulatedHuman2.LeftController

Obtenha o controlador 6 DOF à esquerda.

Microsoft.PerceptionSimulation.ISimulatedHuman2.RightController

Obtenha o controlador 6 DOF correto.

Microsoft.PerceptionSimulation.ISimulatedHand

Interface que descreve uma mão do humano simulado

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

Obtenha a posição do nó com relação ao mundo, em metros.

Microsoft.PerceptionSimulation.ISimulatedHand.Position

Obtenha e defina a posição da mão simulada relativamente ao humano, em metros.

Microsoft.PerceptionSimulation.ISimulatedHand.Activated

Obtenha e defina se a mão está atualmente ativada.

Microsoft.PerceptionSimulation.ISimulatedHand.Visible

Obtenha se a mão está atualmente visível para SimulatedDevice (ou seja, se está numa posição a ser detetada pelo HandTracker).

Microsoft.PerceptionSimulation.ISimulatedHand.EnsureVisible

Mova a mão para que esteja visível para SimulatedDevice.

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

Mova a posição da mão simulada relativamente à sua posição atual, em metros.

Parâmetros

  • tradução – a quantidade para traduzir a mão simulada.

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

Efetue um gesto com a mão simulada. Só será detetado pelo sistema se a mão estiver ativada.

Parâmetros

  • gesto – o gesto a executar.

Microsoft.PerceptionSimulation.ISimulatedHand2

Estão disponíveis propriedades adicionais ao lançar um ISimulatedHand para ISimulatedHand2.

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

Microsoft.PerceptionSimulation.ISimulatedHand2.Orientation

Obter ou definir a rotação da mão simulada. Os radianos positivos rodam no sentido dos ponteiros do relógio ao olhar ao longo do eixo.

Microsoft.PerceptionSimulation.ISimulatedHand3

Estão disponíveis propriedades adicionais ao lançar um ISimulatedHand para 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

Obtenha a configuração conjunta da junta especificada.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetJointConfiguration

Defina a configuração conjunta para a junta especificada.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetHandPose

Defina a mão para uma pose conhecida com um sinalizador opcional para animar. Nota: a animação não resultará em articulações que reflitam imediatamente as respetivas configurações conjuntas finais.

Microsoft.PerceptionSimulation.ISimulatedHead

Interface que descreve a cabeça do humano simulado.

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

Microsoft.PerceptionSimulation.ISimulatedHead.WorldPosition

Obtenha a posição do nó com relação ao mundo, em metros.

Microsoft.PerceptionSimulation.ISimulatedHead.Rotation

Obter a rotação da cabeça simulada. Os radianos positivos rodam no sentido dos ponteiros do relógio ao olhar ao longo do eixo.

Microsoft.PerceptionSimulation.ISimulatedHead.Diameter

Obtenha o diâmetro da cabeça simulada. Este valor é utilizado para determinar o centro da cabeça (ponto de rotação).

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

Rode a cabeça simulada relativamente à rotação atual. Os radianos positivos rodam no sentido dos ponteiros do relógio ao olhar ao longo do eixo.

Parâmetros

  • rotação – a quantidade a rodar.

Microsoft.PerceptionSimulation.ISimulatedHead2

Estão disponíveis propriedades adicionais ao lançar um ISimulatedHead para ISimulatedHead2

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

Microsoft.PerceptionSimulation.ISimulatedHead2.Eyes

Obtenha os olhos do humano simulado.

Microsoft.PerceptionSimulation.ISimulatedSixDofController

Interface que descreve um controlador de 6 DOF associado ao humano simulado.

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

Obtenha a posição do nó com relação ao mundo, em metros.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Status

Obtenha ou defina o estado atual do controlador. O estado do controlador tem de ser definido para um valor diferente de Desativado antes de quaisquer chamadas para mover, rodar ou premir botões serem bem-sucedidas.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Position

Obtenha ou defina a posição do controlador simulado em relação ao humano, em medidores.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Orientation

Obtenha ou defina a orientação do controlador simulado.

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

Mova a posição do controlador simulado relativamente à sua posição atual, em metros.

Parâmetros

  • tradução – a quantidade para traduzir o controlador simulado.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.PressButton(SimulatedSixDofControllerButton)

Prima um botão no controlador simulado. Só será detetado pelo sistema se o controlador estiver ativado.

Parâmetros

  • - O botão a premir.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.ReleaseButton(SimulatedSixDofControllerButton)

Solte um botão no controlador simulado. Só será detetado pelo sistema se o controlador estiver ativado.

Parâmetros

  • button - O botão a libertar.

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

Obtenha a posição de um dedo simulado no touchpad do controlador simulado.

Parâmetros

  • x – a posição horizontal do dedo.
  • y - A posição vertical do dedo.

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

Defina a posição de um dedo simulado no touchpad do controlador simulado.

Parâmetros

  • x – a posição horizontal do dedo.
  • y - A posição vertical do dedo.

Microsoft.PerceptionSimulation.ISimulatedSixDofController2

Estão disponíveis propriedades e métodos adicionais ao lançar um ISimulatedSixDofController para 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)

Obtenha a posição do manípulo simulado no controlador simulado.

Parâmetros

  • x - A posição horizontal do manípulo.
  • y - A posição vertical do manípulo.

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

Defina a posição do thumbstick simulado no controlador simulado.

Parâmetros

  • x - A posição horizontal do manípulo.
  • y - A posição vertical do manípulo.

Microsoft.PerceptionSimulation.ISimulatedSixDofController2.BatteryLevel

Obtenha ou defina o nível de bateria do controlador simulado. O valor tem de ser maior que 0,0 e menor ou igual a 100,0.

Microsoft.PerceptionSimulation.ISimulatedEyes

Interface que descreve os olhos do humano simulado.

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

Microsoft.PerceptionSimulation.ISimulatedEyes.Rotation

Obtenha a rotação dos olhos simulados. Os radianos positivos rodam no sentido dos ponteiros do relógio ao olhar ao longo do eixo.

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

Rode os olhos simulados relativamente à rotação atual. Os radianos positivos rodam no sentido dos ponteiros do relógio ao olhar ao longo do eixo.

Parâmetros

  • rotação – a quantidade a rodar.

Microsoft.PerceptionSimulation.ISimulatedEyes.CalibrationState

Obtém ou define o estado de calibragem dos olhos simulados.

Microsoft.PerceptionSimulation.ISimulatedEyes.WorldPosition

Obtenha a posição do nó com relação ao mundo, em metros.

Microsoft.PerceptionSimulation.ISimulationRecording

Interface para interagir com uma única gravação carregada para reprodução.

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

Microsoft.PerceptionSimulation.ISimulationRecording.DataTypes

Obtém a lista de tipos de dados na gravação.

Microsoft.PerceptionSimulation.ISimulationRecording.State

Obtém o estado atual da gravação.

Microsoft.PerceptionSimulation.ISimulationRecording.Play

Inicie a reprodução. Se a gravação estiver em pausa, a reprodução será retomada a partir da localização em pausa; se for parada, a reprodução começará no início. Se já estiver a ser reproduzida, esta chamada é ignorada.

Microsoft.PerceptionSimulation.ISimulationRecording.Pause

Coloca a reprodução em pausa na localização atual. Se a gravação for parada, a chamada é ignorada.

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

Procura a gravação para a hora especificada (em intervalos de 100 nanossegundos desde o início) e coloca em pausa nessa localização. Se a hora estiver para além do fim da gravação, será colocada em pausa no último fotograma.

Parâmetros

  • tiques - o tempo para o qual procurar.

Microsoft.PerceptionSimulation.ISimulationRecording.Stop

Para a reprodução e repõe a posição para o início.

Microsoft.PerceptionSimulation.ISimulationRecordingCallback

Interface para receber alterações de estado durante a reprodução.

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

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

Chamado quando o estado de reprodução de um ISimulationRecording foi alterado.

Parâmetros

  • newState – o novo estado da gravação.

Microsoft.PerceptionSimulation.PerceptionSimulationManager

Objeto raiz para criar objetos de Simulação de Perceção.

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)

Crie no objeto para gerar pacotes simulados e entregá-los ao sink fornecido.

Parâmetros

  • sink – o sink que irá receber todos os pacotes gerados.

Valor devolvido

O Gestor criado.

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

Crie um sink, que armazena todos os pacotes recebidos num ficheiro no caminho especificado.

Parâmetros

  • path - O caminho do ficheiro a criar.

Valor devolvido

O sink criado.

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

Carregue uma gravação a partir do ficheiro especificado.

Parâmetros

  • path - O caminho do ficheiro a carregar.
  • factory - Uma fábrica utilizada pela gravação para criar um ISimulationStreamSink quando necessário.

Valor devolvido

A gravação carregada.

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

Carregue uma gravação a partir do ficheiro especificado.

Parâmetros

  • path - O caminho do ficheiro a carregar.
  • factory - Uma fábrica utilizada pela gravação para criar um ISimulationStreamSink quando necessário.
  • chamada de retorno – uma chamada de retorno, que recebe atualizações que reveem o estado da gravação.

Valor devolvido

A gravação carregada.

Microsoft.PerceptionSimulation.StreamDataTypes

Descreve os diferentes tipos de dados de fluxo.

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

Um valor sentinel utilizado para indicar que não existem tipos de dados de fluxo.

Microsoft.PerceptionSimulation.StreamDataTypes.Head

Fluxo de dados para a posição e orientação da cabeça.

Microsoft.PerceptionSimulation.StreamDataTypes.Hands

Fluxo de dados para a posição e gestos das mãos.

Microsoft.PerceptionSimulation.StreamDataTypes.SpatialMapping

Fluxo de dados para mapeamento espacial do ambiente.

Microsoft.PerceptionSimulation.StreamDataTypes.Calibration

Fluxo de dados para calibragem do dispositivo. Os pacotes de calibragem só são aceites por um sistema no Modo Remoto.

Microsoft.PerceptionSimulation.StreamDataTypes.Environment

Fluxo de dados para o ambiente do dispositivo.

Microsoft.PerceptionSimulation.StreamDataTypes.SixDofControllers

Fluxo de dados para controladores de movimento.

Microsoft.PerceptionSimulation.StreamDataTypes.Eyes

Fluxo de dados com os olhos do humano simulado.

Microsoft.PerceptionSimulation.StreamDataTypes.DisplayConfiguration

Fluxo de dados com a configuração de apresentação do dispositivo.

Microsoft.PerceptionSimulation.StreamDataTypes.All

Um valor de sentinel utilizado para indicar todos os tipos de dados registados.

Microsoft.PerceptionSimulation.ISimulationStreamSink

Um objeto que recebe pacotes de dados de um fluxo de simulação.

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

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

Recebe um único pacote, que é escrito internamente e com versões.

Parâmetros

  • length - O comprimento do pacote.
  • packet - Os dados do pacote.

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory

Um objeto que cria ISimulationStreamSink.

public interface ISimulationStreamSinkFactory
{
    ISimulationStreamSink CreateSimulationStreamSink();
}

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory.CreateSimulationStreamSink()

Cria uma única instância de ISimulationStreamSink.

Valor devolvido

O sink criado.