Simulação de percepção

Deseja criar um teste automatizado para seu aplicativo? Você quer que seus testes vão além do teste de unidade no nível do componente e realmente exercitem seu aplicativo de ponta a ponta? Simulação de percepção é o que você está procurando. A biblioteca do Perception Simulation envia dados de entrada humanos e mundiais para seu aplicativo para que você possa automatizar seus testes. Por exemplo, você pode simular a entrada de um humano olhando para uma posição específica e repetível e, em seguida, usar um controlador de gesto ou movimento.

A Simulação de Percepção pode enviar entradas simuladas como essa para um HoloLens físico, o emulador do HoloLens (primeira geração), o Emulador do HoloLens 2 ou um computador com o Portal de Realidade Misturada instalado. A Simulação de Percepção ignora os sensores dinâmicos em um dispositivo de Realidade Misturada e envia entrada simulada para aplicativos em execução no dispositivo. Os aplicativos recebem esses eventos de entrada por meio das mesmas APIs que sempre usam e não podem dizer a diferença entre executar com sensores reais e Simulação de Percepção. A Simulação de Percepção é a mesma tecnologia usada pelos emuladores do HoloLens para enviar entrada simulada para a Máquina Virtual do HoloLens.

Para começar a usar a simulação em seu código, comece criando um objeto IPerceptionSimulationManager. A partir desse objeto, você pode emitir comandos para controlar as propriedades de um "humano" simulado, incluindo a posição da cabeça, a posição da mão e os gestos. Você também pode ativar e manipular controladores de movimento.

Configurando um projeto do Visual Studio para simulação de percepção

1. Instale o emulador do HoloLens em seu computador de desenvolvimento. O emulador inclui as bibliotecas que você usa para a Simulação de Percepção.

2. Crie um novo projeto da área de trabalho do Visual Studio C# (um Projeto de Console funciona muito bem para começar).

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

   Observação

   Embora os binários façam parte do Emulador do HoloLens 2, eles também funcionam para Windows Mixed Reality na área de trabalho.)

   a. PerceptionSimulationManager.Interop.dll - Wrapper C# gerenciado para Simulação de Percepção.
   b. PerceptionSimulationRest.dll – Biblioteca para configurar um canal de comunicação de soquete da Web para o HoloLens ou emulador.
   c. SimulationStream.Interop.dll - Tipos compartilhados para simulação.

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

   a. Primeiro, adicione-o como um binário ao projeto (Project-Add-Existing>> Item...). Salve-o como um link para que ele não o copie para a pasta de origem do projeto.
   

   b. Em seguida, certifique-se de que ele seja copiado para sua pasta de saída na compilação. Isso está na folha de propriedades do binário.
   

5. Defina sua plataforma de solução ativa como x64. (Use o Configuration Manager para criar uma entrada de plataforma para x64 se ainda não existir.)

Criando um objeto IPerceptionSimulation Manager

Para controlar a simulação, você emitirá atualizações para objetos recuperados de um objeto IPerceptionSimulationManager. A primeira etapa é obter esse objeto e conectá-lo ao dispositivo ou emulador de destino. Você pode obter o endereço IP do seu emulador clicando no botão Portal de dispositivos na barra de ferramentas

Abrir Portal de Dispositivos: abra o Portal de Dispositivos do Windows para o sistema operacional HoloLens no emulador. Para Windows Mixed Reality, isso pode ser recuperado no aplicativo Configurações em "Atualização e Segurança" e, em seguida, "Para desenvolvedores" na seção "Conectar usando:" em "Habilitar Portal de Dispositivos". Certifique-se de anotar o endereço IP e a porta.

Primeiro, você chamará RestSimulationStreamSink.Create para obter um objeto RestSimulationStreamSink. Esse é o dispositivo ou emulador de destino que você controlará em uma conexão http. Seus comandos serão passados e manipulados pelo Portal de Dispositivos do 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 usuário/senha para se conectar ao Portal de Dispositivos do Windows no dispositivo ou emulador de destino. Se você estiver se conectando ao emulador por meio de seu endereço local (por exemplo, 168... *) no mesmo PC, quaisquer credenciais serão aceitas.
• bool normal - True para prioridade normal, false para baixa prioridade. Geralmente, você deseja definir isso como true para cenários de teste, o que permite que seu teste assuma o controle. O emulador e a simulação do Windows Mixed Reality usam conexões de baixa prioridade. Se o teste também usar uma conexão de baixa prioridade, a conexão estabelecida mais recentemente estará no controle.
• Token System.Threading.CancellationToken - Token para cancelar a operação assíncrona.

Em segundo lugar, você criará o IPerceptionSimulationManager. Este é o objeto que você usa para controlar a simulação. Isso também deve ser feito em um método assíncrono.

Controle o humano simulado

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

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

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

Aplicativo de console C# de exemplo estendido

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 sobre controladores de 6 DOF

Antes de chamar qualquer propriedade em métodos em um controlador de 6 DOF simulado, você deve ativar o controlador. Não fazer isso resultará em uma exceção. A partir da Atualização de maio de 2019 do Windows 10, os controladores de 6 DOF simulados podem ser instalados e ativados definindo a propriedade Status no objeto ISimulatedSixDofController como SimulatedSixDofControllerStatus.Active. Na Atualização de outubro de 2018 do Windows 10 e anteriores, você deve instalar separadamente um controlador de 6 DOF simulado primeiro chamando a ferramenta PerceptionSimulationDevice localizada na pasta \Windows\System32. O uso desta ferramenta é o seguinte:

    PerceptionSimulationDevice.exe <action> 6dof <instance>

Por exemplo

    PerceptionSimulationDevice.exe i 6dof 1

As ações com suporte são:

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

As instâncias suportadas são:

• 1 = o controlador de 6 DOF esquerdo
• 2 = o controlador de 6 DOF direito

O código de saída do processo indicará êxito (um valor de retorno zero) ou falha (um valor de retorno diferente de zero). Ao usar a ação 'q' para consultar se um controlador está instalado, o valor retornado 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 seu status como Desativado por meio da API primeiro e, em seguida, chame a ferramenta PerceptionSimulationDevice.

Esta ferramenta deve ser executada como Administrador.

Referência da 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, o padrão para PerceptionSimulationManager

Microsoft.PerceptionSimulation.HeadTrackerMode

Descreve um modo de rastreador de cabeça

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

Microsoft.PerceptionSimulation.HeadTrackerMode.Default

Rastreamento de cabeça padrão. Isso significa que o sistema pode selecionar o melhor modo de rastreamento de cabeça com base nas condições de tempo de execução.

Microsoft.PerceptionSimulation.HeadTrackerMode.Orientation

Orientação apenas rastreamento de cabeça. Isso significa que a posição rastreada pode não ser confiável e algumas funcionalidades dependentes da posição da cabeça podem não estar disponíveis.

Microsoft.PerceptionSimulation.HeadTrackerMode.Position

Rastreamento de cabeça posicional. Isso significa que a posição e a orientação do cabeçote rastreado são confiá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 sentinela usado para indicar nenhum gesto.

Microsoft.PerceptionSimulation.SimulatedGesture.FingerPressed

Um gesto de dedo pressionado.

Microsoft.PerceptionSimulation.SimulatedGesture.FingerReleased

Um gesto de dedo solto.

Microsoft.PerceptionSimulation.SimulatedGesture.Home

O gesto de casa/sistema.

Microsoft.PerceptionSimulation.SimulatedGesture.Max

O gesto máximo válido.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus

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

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

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Off

O controlador de 6 DOF está desligado.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Active

O controlador de 6 DOF é ligado e rastreado.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.TrackingLost

O controlador de 6 graus de liberdade está ligado, mas não pode ser rastreado.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton

Os botões suportados em um controlador simulado de 6 DOF.

public enum SimulatedSixDofControllerButton
{
    None = 0,
    Home = 1,
    Menu = 2,
    Grip = 4,
    TouchpadPress = 8,
    Select = 16,
    TouchpadTouch = 32,
    Thumbstick = 64,
    Max = Thumbstick
}

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.None

Um valor sentinela usado para indicar que não há botões.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Home

O botão Home é pressionado.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Menu

O botão Menu é pressionado.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Grip

O botão Grip é pressionado.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.TouchpadPress

O TouchPad é pressionado.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Select

O botão Selecionar é pressionado.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.TouchpadTouch

O TouchPad é tocado.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Thumbstick

O direcional analógico é pressionado.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Max

O botão máximo válido.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState

O estado de calibração dos olhos simulados

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

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Unavailable

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

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Ready

Os olhos foram calibrados. Este é o valor padrão.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Configuring

Os olhos estão sendo calibrados.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.UserCalibrationNeeded

Os olhos precisam ser calibrados.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy

A precisão de rastreamento 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 é rastreada.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Approximate

A posição conjunta é inferida.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Visible

A junta é totalmente rastreada.

Microsoft.PerceptionSimulation.SimulatedHandPose

A precisão de rastreamento 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 são configuradas para refletir uma pose fechada.

Microsoft.PerceptionSimulation.SimulatedHandPose.Open

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

Microsoft.PerceptionSimulation.SimulatedHandPose.Point

As articulações dos dedos da mão são configuradas para refletir uma pose de apontamento.

Microsoft.PerceptionSimulation.SimulatedHandPose.Pinch

As articulações dos dedos da mão são configuradas para refletir uma pose de beliscão.

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á parada e pronta para reprodução.

Microsoft.PerceptionSimulation.PlaybackState.Playing

A gravação está sendo reproduzida no momento.

Microsoft.PerceptionSimulation.PlaybackState.Paused

A gravação está pausada no momento.

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, para baixo em torno do eixo X.

Microsoft.PerceptionSimulation.Rotation3.Yaw

O componente de guinada da rotação, bem ao redor do eixo Y.

Microsoft.PerceptionSimulation.Rotation3.Roll

O componente Rolar da rotação, ao redor do eixo Z.

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

Construa uma nova Rotação3.

Parâmetros

• pitch - O componente de pitch da rotação.
• guinada: o componente de guinada da rotação.
• roll - O componente de rolagem da rotação.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration

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

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

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.Position

A posição da articulação.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.Rotation

A rotação da articulação.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.TrackingAccuracy

A precisão de rastreamento da junta.

Microsoft.PerceptionSimulation.Frustum

Descreve um tronco de exibição, como normalmente usado por uma câmera.

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

Microsoft.PerceptionSimulation.Frustum.Near

A distância mínima contida no tronco.

Microsoft.PerceptionSimulation.Frustum.Far

A distância máxima contida no tronco.

Microsoft.PerceptionSimulation.Frustum.FieldOfView

O campo de visão horizontal do tronco, em radianos (menor que PI).

Microsoft.PerceptionSimulation.Frustum.AspectRatio

A razão entre o campo de visão horizontal e o campo de visão vertical.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration

Descreve a configuração da exibição do fone de ouvido 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 renderização estéreo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.LeftEyeRotation

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

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyePosition

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

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyeRotation

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

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.Ipd

O valor de Ipd relatado pelo sistema para fins de renderização estéreo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyEyeTransforms

Se os valores fornecidos para as 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 usados para controlar um dispositivo.

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

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Device

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

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Human

Recupere o objeto que controla o humano simulado.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Reset

Redefine a simulação para seu estado padrão.

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

Recupere o Head Tracker do dispositivo simulado.

Microsoft.PerceptionSimulation.ISimulatedDevice.HandTracker

Recupere o rastreador de mão 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

Propriedades adicionais estão disponíveis convertendo o ISimulatedDevice em ISimulatedDevice2

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

};

Microsoft.PerceptionSimulation.ISimulatedDevice2.IsUserPresent

Recupere ou defina se o humano simulado está ou não usando ativamente o fone de ouvido.

Microsoft.PerceptionSimulation.ISimulatedDevice2.DisplayConfiguration

Recupere ou defina as propriedades da exibição simulada.

Microsoft.PerceptionSimulation.ISimulatedHeadTracker

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

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

Microsoft.PerceptionSimulation.ISimulatedHeadTracker.HeadTrackerMode

Recupera e define o modo de rastreador de cabeça atual.

Microsoft.PerceptionSimulation.ISimulatedHandTracker

Interface que descreve a parte do dispositivo simulado que rastreia 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

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

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Position

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

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Pitch

Recupere e defina a inclinação para baixo do rastreador de mão simulado.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.FrustumIgnored

Recupere e defina se o tronco do rastreador de mão simulado é ignorado. Quando ignoradas, ambas as mãos estão sempre visíveis. Quando não ignoradas (o padrão), as mãos só são visíveis quando estão dentro do tronco do rastreador de mão.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Frustum

Recupere e defina as propriedades do tronco usadas para determinar se as mãos estão visíveis para o rastreador de mão 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

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

Microsoft.PerceptionSimulation.ISimulatedHuman.Direction

Recupere e defina a direção que o humano simulado enfrenta no mundo. 0 radianos estão voltados para baixo no eixo Z negativo. Os radianos positivos giram no sentido horário em torno do eixo Y.

Microsoft.PerceptionSimulation.ISimulatedHuman.Height

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

Microsoft.PerceptionSimulation.ISimulatedHuman.LeftHand

Recupere a mão esquerda do humano simulado.

Microsoft.PerceptionSimulation.ISimulatedHuman.RightHand

Recupere a mão direita do humano simulado.

Microsoft.PerceptionSimulation.ISimulatedHuman.Head

Recupere a cabeça do humano simulado.

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

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

Parâmetros

• translation - A translação a ser movida, em relação à posição atual.

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

Gire o humano simulado em relação à sua direção atual, no sentido horário em relação ao eixo Y

Parâmetros

• radianos - A quantidade a ser girada em torno do eixo Y.

Microsoft.PerceptionSimulation.ISimulatedHuman2

Propriedades adicionais estão disponíveis convertendo o ISimulatedHuman em ISimulatedHuman2

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

Microsoft.PerceptionSimulation.ISimulatedHuman2.LeftController

Recupere o controlador de 6 DOF esquerdo.

Microsoft.PerceptionSimulation.ISimulatedHuman2.RightController

Recupere o controlador de 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

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

Microsoft.PerceptionSimulation.ISimulatedHand.Position

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

Microsoft.PerceptionSimulation.ISimulatedHand.Activated

Recupere e defina se a mão está ativada no momento.

Microsoft.PerceptionSimulation.ISimulatedHand.Visible

Recupere se a mão está visível no momento para o SimulatedDevice (ou seja, se ela está em uma posição para ser detectada pelo HandTracker).

Microsoft.PerceptionSimulation.ISimulatedHand.EnsureVisible

Mova a mão de forma que ela fique visível para o SimulatedDevice.

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

Mova a posição do ponteiro simulado em relação à 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)

Execute um gesto usando a mão simulada. Ele só será detectado pelo sistema se a mão estiver habilitada.

Parâmetros

• gesture - O gesto a ser executado.

Microsoft.PerceptionSimulation.ISimulatedHand2

Propriedades adicionais estão disponíveis convertendo um ISimulatedHand em ISimulatedHand2.

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

Microsoft.PerceptionSimulation.ISimulatedHand2.Orientation

Recupere ou defina a rotação da mão simulada. Os radianos positivos giram no sentido horário ao olhar ao longo do eixo.

Microsoft.PerceptionSimulation.ISimulatedHand3

Propriedades adicionais estão disponíveis convertendo um ISimulatedHand em 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 da junta para a junta especificada.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetJointConfiguration

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

Microsoft.PerceptionSimulation.ISimulatedHand3.SetHandPose

Defina a mão para uma pose conhecida com um sinalizador opcional para animar. Observação: a animação não resultará em juntas refletindo imediatamente suas configurações finais de juntas.

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

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

Microsoft.PerceptionSimulation.ISimulatedHead.Rotation

Recupere a rotação da cabeça simulada. Os radianos positivos giram no sentido horário ao olhar ao longo do eixo.

Microsoft.PerceptionSimulation.ISimulatedHead.Diameter

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

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

Gire a cabeça simulada em relação à sua rotação atual. Os radianos positivos giram no sentido horário ao olhar ao longo do eixo.

Parâmetros

• rotation - A quantidade a ser girada.

Microsoft.PerceptionSimulation.ISimulatedHead2

Propriedades adicionais estão disponíveis convertendo um ISimulatedHead em ISimulatedHead2

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

Microsoft.PerceptionSimulation.ISimulatedHead2.Eyes

Recupere 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

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

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Status

Recupere ou defina o estado atual do controlador. O status do controlador deve ser definido como um valor diferente de Desligado antes que qualquer chamada para mover, girar ou pressionar botões seja bem-sucedida.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Position

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

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Orientation

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

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

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

Parâmetros

• translation - A quantidade para converter o controlador simulado.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.PressButton(SimulatedSixDofControllerButton)

Pressione um botão no controlador simulado. Ele só será detectado pelo sistema se o controlador estiver habilitado.

Parâmetros

• button - O botão a ser pressionado.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.ReleaseButton(SimulatedSixDofControllerButton)

Solte um botão no controlador simulado. Ele só será detectado pelo sistema se o controlador estiver habilitado.

Parâmetros

• button - O botão a ser liberado.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.GetTouchpadPosition(flutuação de saída, flutuação de saída)

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

Propriedades e métodos adicionais estão disponíveis convertendo um ISimulatedSixDofController em 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(flutuação de saída, flutuação de saída)

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

Parâmetros

• x - A posição horizontal do polegar.
• y - A posição vertical do polegar.

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

Defina a posição do direcional analógico simulado no controlador simulado.

Parâmetros

• x - A posição horizontal do polegar.
• y - A posição vertical do polegar.

Microsoft.PerceptionSimulation.ISimulatedSixDofController2.BatteryLevel

Recupere ou defina o nível da bateria do controlador simulado. O valor deve 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

Recupere a rotação dos olhos simulados. Os radianos positivos giram no sentido horário ao olhar ao longo do eixo.

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

Gire os olhos simulados em relação à sua rotação atual. Os radianos positivos giram no sentido horário ao olhar ao longo do eixo.

Parâmetros

• rotation - A quantidade a ser girada.

Microsoft.PerceptionSimulation.ISimulatedEyes.CalibrationState

Recupera ou define o estado de calibração dos olhos simulados.

Microsoft.PerceptionSimulation.ISimulatedEyes.WorldPosition

Recupere a posição do nó em 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

Recupera a lista de tipos de dados na gravação.

Microsoft.PerceptionSimulation.ISimulationRecording.State

Recupera o estado atual da gravação.

Microsoft.PerceptionSimulation.ISimulationRecording.Play

Inicie a reprodução. Se a gravação for pausada, a reprodução será retomada a partir do local pausado; Se parado, a reprodução começará no início. Se já estiver sendo reproduzido, essa chamada será ignorada.

Microsoft.PerceptionSimulation.ISimulationRecording.Pause

Pausa a reprodução em seu local atual. Se a gravação for interrompida, a chamada será ignorada.

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

Busca a gravação no tempo especificado (em intervalos de 100 nanossegundos desde o início) e pausa nesse local. Se o tempo estiver além do final da gravação, ele será pausado no último quadro.

Parâmetros

• ticks - O tempo para o qual procurar.

Microsoft.PerceptionSimulation.ISimulationRecording.Stop

Interrompe a reprodução e redefine 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 é alterado.

Parâmetros

• newState - O novo estado da gravação.

Microsoft.PerceptionSimulation.PerceptionSimulationManager

Objeto raiz para criar objetos do Perception Simulation.

public static class PerceptionSimulationManager
{
    public static IPerceptionSimulationManager CreatePerceptionSimulationManager(ISimulationStreamSink sink);
    public static ISimulationStreamSink CreatePerceptionSimulationRecording(string path);
    public static ISimulationRecording LoadPerceptionSimulationRecording(string path, ISimulationStreamSinkFactory factory);
    public static ISimulationRecording LoadPerceptionSimulationRecording(string path, ISimulationStreamSinkFactory factory, ISimulationRecordingCallback callback);

Microsoft.PerceptionSimulation.PerceptionSimulationManager.CreatePerceptionSimulationManager(Microsoft.PerceptionSimulation.ISimulationStreamSink)

Criar no objeto para gerar pacotes simulados e entregá-los ao coletor fornecido.

Parâmetros

• sink - O coletor que receberá todos os pacotes gerados.

Valor retornado

O gerente criado.

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

Crie um coletor, que armazena todos os pacotes recebidos em um arquivo no caminho especificado.

Parâmetros

• path - O caminho do arquivo a ser criado.

Valor retornado

O coletor criado.

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

Carregue uma gravação do arquivo especificado.

Parâmetros

• path - O caminho do arquivo a ser carregado.
• factory – uma fábrica usada pela gravação para criar um ISimulationStreamSink quando necessário.

Valor retornado

A gravação carregada.

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

Carregue uma gravação do arquivo especificado.

Parâmetros

• path - O caminho do arquivo a ser carregado.
• factory – uma fábrica usada pela gravação para criar um ISimulationStreamSink quando necessário.
• callback - Um retorno de chamada, que recebe atualizações que reavaliam o status da gravação.

Valor retornado

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 sentinela usado para indicar nenhum tipo 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 calibração do dispositivo. Os pacotes de calibração só são aceitos 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 exibição do dispositivo.

Microsoft.PerceptionSimulation.StreamDataTypes.All

Um valor sentinela usado para indicar todos os tipos de dados registrados.

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 é digitado internamente e com controle de versão.

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 retornado

O coletor criado.